from sqlalchemy.orm import sessionmaker
from dbmodels import DBEngine, FZ54, metadata, FZ54Details, Sell, PayloadTable, ErrorTable, DocTable, AtolTable
from atol import Atol
from basemodels import Error, SellBaseModel, DocModel
from time import sleep
from datetime import datetime
import json


def db_init():
    server = '172.16.1.150:1433'
    user = 'sa'
    password = '159357'
    dbname = 'fz54'
    db = DBEngine(server, dbname, user, password)
    dbname = 'fz54_details'
    dbinfo = DBEngine(server, dbname, user, password)
    return db, dbinfo


def main():
    db_fz, db_fzdetails = db_init()
    models = FZ54(db_fz)
    metadata.create_all(db_fz.engine)
    details = FZ54Details(db_fzdetails)
    return models, details


def sell(fz, fzd, timestp):
    res = Sell(fz, fzd, timestp)
    dicts = res.make()
    return dicts


def clear_dict(d):
    if d is None:
        return None
    elif isinstance(d, list):
        return list(filter(lambda x: x is not None, map(clear_dict, d)))
    elif not isinstance(d, dict):
        return d
    else:
        r = dict(
            filter(lambda x: x[1] is not None,
                   map(lambda x: (x[0], clear_dict(x[1])),
                       d.items())))
        if not bool(r):
            return None
        return r


def connection_db(models):
    Session = sessionmaker(autocommit=False, bind=models.db.engine)
    return Session()


def sell_items(sell_base_models, models):
#    supp_list = connection_db(models).execute(
#        'SELECT DISTINCT LOWER(external_id) FROM items where supplier_info IS NOT NULL').fetchall()
    for sell_base_model in sell_base_models:
        sbm = clear_dict(sell_base_model.dict())
        ext_id = sbm.get('external_id')        
#        if ext_id in list(supp_list):
#            continue
        token = connection_db(models).execute('SELECT token FROM dbo.vAtolToken').fetchone()
        session1 = Atol(token)
        sss = connection_db(models)
        try:
            sell = session1.set_sell(sbm)
            sell['external_id'] = ext_id
            err_sell = sell.pop('error')
            doc_model = clear_dict(sell)
            try:
                atol = AtolTable(**doc_model)
                sss.add(atol)
                sss.commit()
            except Exception as e:
                sss.rollback()
        except Exception:
            error = err_sell
            error['external_id'] = ext_id
            err = ErrorTable(**error)
            zz = connection_db(models)
            try:
                zz.add(err)
                zz.commit()
            except Exception as e:
                zz.rollback()
            finally:
                zz.close()
        finally:
            sss.close()
        sleep(2)


def get_receipt(uuid, ext_id, models, atol_session):
    sell = atol_session.get_reciepts(uuid)
    session = connection_db(models)
    try:

        doc_dict = DocModel(**sell)
        doc_model = doc_dict.dict()
        error = doc_model.pop('error')
        payload = doc_model.pop('payload')
        if type(error) is dict:
            try:
                error['external_id'] = ext_id
                err = ErrorTable(**error)
            except Exception as e:
                print(e)
        if type(payload) is dict:
            try:
                payload['external_id'] = ext_id
                pay = PayloadTable(**payload)
            except Exception as e:
                print(e)
        doc = DocTable(**doc_model)
        if type(payload) is dict:
            session.add(doc)
            session.add(pay)
            session.commit()
        elif type(error) is dict:
            session.add(doc)
            session.add(err)
            session.commit()
    except Exception as e:
        error = sell.get('error')
        error['external_id'] = ext_id
        err = ErrorTable(**error)
        ss = session
        try:
            ss.add(err)
            ss.commit()
        except Exception as e:
            print(e)
            ss.rollback()
    finally:
        session.close()


def remove_tuple(lst):
    return [item[0] for item in lst]


if __name__ == "__main__":
    year = 2021
    month = 6
    day = 11
    starttime = datetime.now()
    models, details = main()
    timestamp = datetime(year, month, day, 0, 0, 0)
    sell_models = sell(models, details, timestamp)
    sell_base_models = SellBaseModel().parse(db_dict_list=sell_models)
    inst_list_query = 'SELECT external_id FROM sell WHERE external_id NOT IN(\
                        SELECT external_id FROM atol_receipt )\
                        ORDER BY [timestamp]'
    inst_list = connection_db(models).execute(inst_list_query).fetchall()
    sell_base_models = [model for model in sell_base_models if model.dict().get(
        'external_id') in remove_tuple(inst_list)]
    sell_items(sell_base_models, models)
    endfirsttime = datetime.now()
    deltatime = starttime - endfirsttime
    print(f'прошло {deltatime.seconds}')
    receipt_list = connection_db(models).execute(
        "SELECT external_id, uuid FROM atol_receipt WHERE external_id not in (select external_id FROM docs)")
    for rec in list(receipt_list):
        sleep(0.05)
        ext_id, uuid = rec
        token = connection_db(models).execute('SELECT token FROM dbo.vAtolToken').fetchone()
        done = get_receipt(uuid, ext_id, models, Atol(token))
        sleep(0.05)
    donetime = datetime.now()
    deltaendtime = starttime - donetime
    print(f'прошло {deltaendtime.seconds}')