"""things to do with reports"""

import glob
import os
import sys

import filing
from nitpo import Nitpo
from sheets import Sheets

class Reports(Nitpo):

    def __init__(self, do_verbose=False):
        """report configuration"""
        self.do_verbose = do_verbose
        super().__init__()
        if not self.has_conf('ext', 'report'):
            print("reports: need an [ext][report] configuration",
                  file=sys.stderr)
            sys.exit(1)
        if not self.has_conf('folders', 'reports'):
            print("reports: I see no reports directory.")
            sys.exit(1)
        # # orims structure to maintain
        self.orimas = {}
        self.ext_len = len(self.conf['ext']['report'])
        self.sheets = Sheets(do_verbose)
        self.reports_fudi = self.conf['folders']['reports']
        self.reports_glob = self.reports_fudi + '/*'

    def fufis(self, only_repcode=None):
        """gets the report files"""
        if not self.has_conf('folders', 'reports'):
            print("reports: I see no reports directory.")
            quit()
        fufis = {}
        # print(self.reports_glob)
        for report_fufi in glob.glob(self.reports_glob):
            if report_fufi.endswith('~'):
                continue
            test_fufi = report_fufi
            if report_fufi.endswith('.gz'):
                test_fufi = report_fufi[:-3]
            if not test_fufi.endswith(self.conf['ext']['report']):
                print(f"reports: I skip '{report_fufi}'.")
                continue
            report_bana = os.path.basename(test_fufi)
            repcode = report_bana[:-self.ext_len]
            # print(repcode)
            if only_repcode is not None and repcode != only_repcode:
                continue
            fufis[repcode] = report_fufi
        return fufis

    def get_orimas(self, only_repcode=None, do_lazy=True,
                   get_cache_only=False):
        """get orimas and store in [files][orimas]"""
        if not self.has_conf('files', 'orimas'):
            print("reports: I need a [files][orimas] configuration.")
            sys.exit(1)
        orima_fufi = self.conf['files']['orimas']
        fufis = self.fufis(only_repcode=only_repcode)
        i_need_to_save = False
        if os.path.isfile(orima_fufi) and (do_lazy or get_cache_only):
            orimas = filing.load(orima_fufi)
            if get_cache_only:
                return orimas
        else:
            orimas = {}
            # # by report
            orimas['r'] = {}
            # # by emad, first emad only
            orimas['e'] = {}
        for repcode in fufis:
            fufi = fufis[repcode]
            # # lazy mode: don't read files older than the cache files
            # # once per week should be run with non-lazy mode
            if do_lazy and not filing.donere(orima_fufi, [fufi]):
                continue
            i_need_to_save = True
            # # reports are is the report directory, with the repcode followed
            # # by the extension
            repdoc = filing.parse_lax(fufi)
            # # gives a newline separated text of emad
            emads = str(self.sheets.get_result('orimas', repdoc))
            emads = emads.split('\n')
            if repcode in orimas:
                print(f"reports: looks like several configurations of report {repcode}",
                      file=sys.stderr)
            orimas['r'][repcode] = []
            count_emads = 0
            for emad in emads:
                emad = emad.lower()
                if len(emad) == 0:
                    continue
                if repcode not in orimas['r']:
                    orimas['r'][repcode] = []
                if emad in orimas['r'][repcode]:
                    print(f"reports: duplicate report emad {emad} for {repcode}.",
                          file=sys.stderr)
                orimas['r'][repcode].append(emad)
                if count_emads > 0:
                    continue
                # # index the emails as well
                if emad not in orimas['e']:
                    orimas['e'][emad] = []
                #if len(repcode) == 0:
                #    continue
                if emad not in orimas['e']:
                    orimas['e'][emad] = []
                orimas['e'][emad].append(repcode)
                count_emads += 1
        self.orimas = orimas
        if i_need_to_save:
            filing.dump(orima_fufi, orimas)
        return orimas

    def does_it_exist(self, repcode):
        """check if a report exist by directory or file name start"""
        if not self.has_conf('folders', 'reports'):
            raise Exception("I need Ф[folders][reports]")
        fudi = self.conf['folders']['reports']
        ## test by directory
        if os.path.isdir(fudi + '/' + repcode):
            return True
        glob_string = fudi + '/' + repcode + '.*'
        found = glob.glob(glob_string)
        if not found:
            return False
        return True

    def load(self, repcode):
        if not self.has_conf('folders', 'reports'):
            if self.do_verbose:
                print("reports does not have a directory")
            return None
        fudi = self.conf['folders']['reports']
        if not self.has_conf('ext', 'report'):
            if self.do_verbose:
                print("reports does not have a report extension")
            return None
        ext = self.conf['ext']['report']
        ## test by file
        fufi = fudi + '/' + repcode + ext
        if not os.path.isfile(fufi):
            if self.do_verbose:
                print(f"reports does not see {fufi}")
            return None
        doc = filing.parse_lax(fufi)
        return doc