"""cached profiles"""

import datetime
import os
import sys
from lxml import etree

import filing
from nitpo import Nitpo
from xpaths import Xpaths


class Kapro(Nitpo):

    def __init__(self, do_verbose=False):
        super().__init__()
        ns = self.const['ns']
        self.nsmap = {None: ns}
        self.N = "{%s}" % self.const['ns']
        self.check_conf('folders', 'profile')
        self.check_conf('folders', 'kapro')
        self.to_print = ''
        self.event = {}
        self.d = {}
        self.dirs = {}
        self.dirs['profile'] = self.conf['folders']['profile']
        self.dirs['kapro'] = self.conf['folders']['kapro']
        self.start_time = datetime.datetime.now().timestamp()
        self.parser = etree.XMLParser(remove_blank_text=True)
        self.x = Xpaths()
        # # state variable
        self.indat = None
        # # library of profiles for brore testing
        self.lib = None
        self.repcode = None
        self.do_verbose = do_verbose

    def all(self):
        """do all reports from scratch"""
        for root, dirs, banas in os.walk(self.dirs['profile']):
            for bana in banas:
                if bana == 'omnibus.xml':
                    continue
                if not bana.endswith(".xml"):
                    continue
                fufi = root + '/' + bana
                doc = filing.parse_lax(fufi, parser=self.parser)
                if doc is None:
                    continue
                self.get_all(doc)
        self.dump_all()

    def dump_all(self):
        for repcode in self.d:
            self.dump(repcode)

    def dump(self, repcode):
        if self.do_verbose:
            print(f"kapro dumps for {repcode}")
        out_fufi = self.get_fufi(repcode)
        filing.dump(out_fufi, self.d[repcode])
        os.utime(out_fufi, (self.start_time, self.start_time))

    def load(self, repcode):
        if self.do_verbose:
            print(f"kapro dumps for {repcode}")
        kapro_fufi = self.get_fufi(repcode)
        if not os.path.isfile(kapro_fufi):
            return {}
        surks = filing.load(kapro_fufi)
        return surks

    def delete(self, repcode, emad):
        if repcode not in self.d:
            self.d[repcode] = self.load(repcode)
        if emad not in self.d[repcode]:
            return False
        del self.d[repcode][emad]
        self.dump(repcode)

    def get_all(self, doc):
        surk_eles = self.x.live_surks(doc)
        if len(surk_eles) == 0:
            return
        emad = self.x.get_emad(doc)
        for surk_ele in surk_eles:
            self.from_surk(surk_ele, emad)

    def from_surk(self, surk_ele, emad):
        repcode = surk_ele.attrib['repcode']
        if repcode not in self.d:
            self.d[repcode] = {}
        self.d[repcode][emad] = surk_ele.attrib['spro']

    def start(self, repcode):
        """start a kapro with no data"""
        self.d[repcode] = {}
        self.dump(repcode)

    def get_fufi(self, repcode):
        out_fufi = self.dirs['kapro'] + '/' + repcode + '.json.gz'
        return out_fufi

    def update(self, repcode):
        """update for a report"""
        out_fufi = self.get_fufi(repcode)
        out_time = 0
        if os.path.isfile(out_fufi):
            out_time = os.path.getmtime(out_fufi)
        fufis = []
        for root, dirs, banas in os.walk(self.dirs['profile']):
            for bana in banas:
                if bana.endswith('~'):
                    continue
                fufi = root + '/' + bana
                if bana == 'omnibus.xml' or bana == 'omnibus.xml.gz':
                    continue
                if not os.path.isfile(fufi):
                    continue
                if os.path.getmtime(fufi) < out_time:
                    if self.do_verbose:
                        print(f"kapro skips {fufi} as too recent.")
                    continue
                if self.do_verbose:
                    print(f"I have to read {fufi}")
                if self.do_verbose:
                    print("kapro adds {fufi}")
                fufis.append(fufi)
        if len(fufis) == 0:
            if self.do_verbose:
                print(f"kapro found no files to update for {repcode}.")
            return False
        if not os.path.isfile(out_fufi):
            if self.do_verbose:
                print(f"kapro does not see {out_fufi}")
            self.indat = {}
        else:
            self.indat = filing.load(out_fufi)
        self.repcode = repcode
        count_updates = 0
        for fufi in fufis:
            needs_update = self.update_for_fufi(fufi)
            count_updates += needs_update
        if count_updates == 0:
            if self.do_verbose:
                print("krapo sees no changes to write.")
            if os.path.isfile(out_fufi):
                os.utime(out_fufi, (self.start_time, self.start_time))
        else:
            if self.do_verbose:
                print(f"krapo writes {out_fufi}")
            filing.dump(self.indat, out_fufi)
        # # set to the start time of the scrip
        self.indat = None
        self.repcode = None

    def update_for_fufi(self, fufi):
        doc = etree.parse(fufi)
        if self.do_verbose:
            print(f"kapro reads {fufi}.")
        live_surk = self.x.live_surk(doc, self.repcode)
        emad = self.x.get_emad(doc)
        if live_surk is None:
            if emad not in self.indat:
                return 0
            if self.do_verbose:
                print(f"kapro dels {emad}.")
            del self.indat[emad]
            return 1
        else:
            if emad in self.indat:
                return 0
            if self.do_verbose:
                print(f"kapro adds {emad}.")
            self.indat[emad] = live_surk.attrib['spro']
            return 1

    def build_lib(self, do_clear=True):
        if not self.has_conf('files', 'libpro'):
            print("reports: I need a [files][libpro] configuration.")
            sys.exit(1)
        libpro_fufi = self.conf['files']['libpro']
        if do_clear and os.path.isfile(libpro_fufi):
            os.remove(libpro_fufi)
        fufis = []
        for root, dirs, banas in os.walk(self.dirs['profile']):
            for bana in banas:
                if not bana.endswith('.xml'):
                    continue
                if bana == 'omnibus.xml':
                    continue
                fufi = root + '/' + bana
                fufis.append(fufi)
        filing.dump(fufis, libpro_fufi)

    def load_lib(self):
        if not self.has_conf('files', 'libpro'):
            print("reports: I need a [files][libpro] configuration.")
            sys.exit(1)
        self.lib = filing.load(self.conf['files']['libpro'])
        return self.lib