# standard imports
import stat
import os
import logging
import json
import urllib.parse
import datetime

# external imports
from hexathon import strip_0x
from cic_types.condiments import MetadataPointer
from cic_types.models.person import Person
from cic_types.ext.requests import make_request
from cic_types.processor import generate_metadata_pointer
from requests.exceptions import HTTPError
import phonenumbers

# local imports
from clicada.encode import tx_normalize
from clicada.store.mem import MemDictStore
from clicada.error import (
        ExpiredRecordError,
        MetadataNotFoundError,
        )

logg = logging.getLogger(__name__)


class Account(Person):

    def __init__(self):
        super(Account, self).__init__()
        self.tags = []


    def apply_custom(self, custom_data):
        self.tags = custom_data['tags']
        logg.debug('tags are now {}'.format(self.tags))


    @classmethod
    def deserialize(cls, person_data):
        o = super(Account, cls).deserialize(person_data)
        try:
            o.tags = person_data['custom']['tags']
        except KeyError as e:
            pass
        return o 


    def serialize(self):
        o = super(Account, self).serialize()
        o['custom'] = {}
        o['custom']['tags'] = self.tags
        return o 


    def __str__(self):
        return '{} {} ({})'.format(
            self.given_name,
            self.family_name,
            self.tel,
            )


class FileUserStore:

    def __init__(self, metadata_opener, chain_spec, label, store_base_path, ttl, encrypter=None):
        invalidate_before = datetime.datetime.now() - datetime.timedelta(seconds=ttl)
        self.invalidate_before = int(invalidate_before.timestamp())
        self.have_xattr = False
        self.label = label
        self.store_path = os.path.join(
                store_base_path,
                chain_spec.arch(),
                chain_spec.fork(),
                str(chain_spec.network_id()),
                self.label,
                )
        self.memstore_entity = MemDictStore()
        os.makedirs(self.store_path, exist_ok=True)
        self.__validate_dir()
        self.metadata_opener = metadata_opener
        self.failed_entities = {}
        self.encrypter = encrypter


    def __validate_dir(self):
        st = os.stat(self.store_path)
        if stat.S_ISDIR(st.st_mode):
            logg.debug('using existing file store {} for {}'.format(self.store_path, self.label))


    def is_dud(self, address):
        return bool(self.failed_entities.get(address))


    def put(self, k, v, force=False):
        have_file = False
        p = os.path.join(self.store_path, k)
        its_time = True
        try:
            st = os.stat(p)
            have_file = True
            its_time = st[stat.ST_MTIME] < self.invalidate_before
        except FileNotFoundError:
            pass

        if have_file and not its_time and not force:
            raise FileExistsError('user resolution already exists for {}'.format(k))

        ve = v
        f = None
        if self.encrypter != None:
            ve = self.encrypter.encrypt(k, ve.encode('utf-8'))
            f = open(p, 'wb')
        else:
            f = open(p, 'w')
        f.write(ve)
        f.close()

        logg.info('added user store {} record {} -> {}'.format(self.label, k, v))


    def stick(self, k):
        p = os.path.join(self.store_path, k)

        if self.have_xattr:
            os.setxattr(p, 'cic_sticky', b'1')
        else:
            (s_h, s_t) = os.path.split(p)
            sp = os.path.join(s_h, '.stick_' + s_t)
            f = open(sp, 'w')
            f.close()


    def __is_sticky(self, p):
        if self.have_xattr:
            if not os.getxattr(p, 'cic_sticky'):
                return False
        else:
            (s_h, s_t) = os.path.split(p)
            sp = os.path.join(s_h, '.stick_' + s_t)
            try:
                os.stat(sp)
            except FileNotFoundError:
                return False
        return True


    def __unstick(self, p):
        (s_h, s_t) = os.path.split(p)
        sp = os.path.join(s_h, '.stick_' + s_t)
        os.unlink(sp)


    def path(self, k):
        return os.path.join(self.store_path, k)


    def sticky(self, k):
        p = self.path(k)
        return self.__is_sticky(p)


    def check_expiry(self, p):
        st = os.stat(p)
        if st[stat.ST_MTIME] < self.invalidate_before:
            if self.__is_sticky(p):
                logg.debug('ignoring sticky record expiry for {}'.format(p))
                return
            raise ExpiredRecordError('record in {} is expired'.format(p))


    def get(self, k, ignore_expired=False):
        try:
            p = os.path.join(self.store_path, k)
        except FileNotFoundError as e:
            if self.__is_sticky(p):
                logg.warning('removed orphaned sticky record for ' + p)
                self.__unstick(p)
        self.check_expiry(p)

        f = None
        if self.encrypter != None:
            f = open(p, 'rb')
        else:
            f = open(p, 'r')
        v = f.read()
        f.close()

        if self.encrypter != None:
            v = self.encrypter.decrypt(k, v)
            logg.debug('>>>>>>>>>>>>< v decoded {}'.format(v))
            v = v.decode('utf-8')

        logg.debug('retrieved {} from {}'.format(k, p))
        return v.strip()


    def by_phone(self, phone, update=False):
        phone = phonenumbers.parse(phone, None)
        phone = phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.E164)
        phone_file = phone.replace('+', '')

        ignore_expired = self.sticky(phone_file)

        if not update:
            try:
                v = self.get(phone_file, ignore_expired=ignore_expired)
                return v
            except FileNotFoundError:
                pass
            except ExpiredRecordError as e:
                logg.info(e)
                pass

        getter = self.metadata_opener
        ptr = generate_metadata_pointer(phone.encode('utf-8'), MetadataPointer.PHONE)
        r = None
        user_address = None
        try:
            r = getter.open(ptr)
            user_address = json.loads(r)
        except HTTPError as e:
            logg.debug('no address found for phone {}: {}'.format(phone, e))
            return None

        self.put(phone_file, user_address, force=update)
        return user_address


    def metadata_to_person(self, v):
        person = Account()
        try:
            person_data = person.deserialize(person_data=v)
        except Exception as e:
            person_data = v
        return person_data


    def by_address(self, address, update=False):
        address = tx_normalize.wallet_address(address)
        address = strip_0x(address)
        #if self.failed_entities.get(address):
        if self.is_dud(address):
            logg.debug('already tried and failed {}, skipping'.format(address))
            return address

        ignore_expired = self.sticky(address)

        if not update:
            try:
                v = self.get(address, ignore_expired=ignore_expired)
                v = json.loads(v)
                return self.metadata_to_person(v)
            except FileNotFoundError:
                pass
            except ExpiredRecordError as e:
                logg.info(e)
                pass

        getter = self.metadata_opener

        ptr = generate_metadata_pointer(bytes.fromhex(address), MetadataPointer.PERSON)
        r = None
        try:
            r = getter.open(ptr)
        except Exception as e:
            logg.debug('no metadata found for {}: {}'.format(address, e))
        
        if not r:
            self.failed_entities[address] = True
            raise MetadataNotFoundError()

        data = json.loads(r)
        person = Account()
        person_data = person.deserialize(person_data=data)

        ptr = generate_metadata_pointer(bytes.fromhex(address), MetadataPointer.CUSTOM)
        r = None
        try:
            r = getter.open(ptr)
            o = json.loads(r)
            person_data.apply_custom(o)
        except Exception as e:
            pass

        self.put(address, json.dumps(person_data.serialize()), force=update)

        return person_data