from sqlalchemy import select
from sqlalchemy.orm import Session

from src.data.model.db.connection import get_sync_engine
from src.data.synchronisation.article_old import *
from src.data.synchronisation.partner_agent_old import *
# utils
import logging
from src.config import settings
from src.data.synchronisation.quantities import *
from src.data.synchronisation.utils import load_xml

logger = logging.getLogger('import_logger')

article_start_tag_path = ['semiramis', 'Item']
price_list_start_tag = ['semiramis', 'PriceList']


def run():
    print("Synchronisation started")
    logger.info("Start of daily import")
    logger.info("read xml import files")

    # process nested dictionaries
    # 1. article
    logger.info("processing of article data")

    article_details_mobi = load_xml(settings.import_files_xml_article_detail_mobi, article_start_tag_path)
    article_details_b2b = ... #load_xml(, article_start_tag_path)
    article_details = article_details_b2b + article_details_mobi

    seasons = process_season(article_details)
    theme_groups = process_theme(article_details)
    item_groups = process_group(article_details)
    colors = process_color(article_details)

    color_images = process_color_images(article_details)
    article_details = list(filter(None, process_article_detail(article_details)))

    articles_mobi = load_xml(settings.import_files_xml_article_mobi, article_start_tag_path)
    articles_b2b = load_xml(settings.import_files_xml_article_b2b, article_start_tag_path)
    articles = articles_mobi + articles_b2b
    article_images = process_article_images(articles)
    articles = process_article(articles)

    article_details = list(
        filter(lambda a_d: a_d.article_number in map(lambda a: a.article_number, articles), article_details))

    eans = list(map(lambda a_d: a_d.ean, article_details))
    price_lists = load_xml(settings.import_files_xml_price_list, price_list_start_tag)
    price_lists = process_pricelist(price_lists)
    price_lists = list(filter(lambda p: p.article_detail_ean in eans, price_lists))

    print("Article data processed")
    # 2. partner
    logger.info("processing of partner data")

    partner_start_tag = ['semiramis', 'Partner']

    partner_data = load_xml(settings.import_files_xml_partner, partner_start_tag)
    partner_relation = load_xml(settings.import_files_xml_partner_relation, partner_start_tag)
    partner_sales_order_type = load_xml(settings.import_files_xml_partner_sales_order_types, partner_start_tag)

    shipping_terms, payment_terms = process_shipping_and_payment_terms(partner_data)
    partner = process_partner(partner_data)
    partner_agent_relation = process_partner_relation(partner_relation)
    sales_order_type_partner = process_sales_order_type_partner(partner_sales_order_type)

    print("Partner data processed")

    # merge with current state of database
    # create session
    engine = get_sync_engine()
    session = Session(bind=engine)
    session.begin()

    sales_order_types = session.execute(select(SalesOrderType)).scalars().all()
    agents = session.execute(select(Agent)).scalars().all()

    allowed_partners = list(map(lambda p: p.partner_num, partner))
    allowed_sales_order = set(map(lambda sales_order: sales_order.code, sales_order_types))
    allowed_price_lists = set(map(lambda price_list: price_list.code, price_lists))
    allowed_agents = set(map(lambda agent: agent.agent_num, agents))
    partner_agent_relation = list(
        filter(lambda partner_agent: int(partner_agent.agent_num) in allowed_agents and partner_agent.partner_num in allowed_partners, partner_agent_relation))
    sales_order_type_partner = list(
        filter(lambda sales_order_p:
               sales_order_p.partner_num in allowed_partners and
               int(sales_order_p.code) in allowed_sales_order and
               sales_order_p.pricelist_code in allowed_price_lists,
               sales_order_type_partner))

    print("Merge export data with database")
    logger.info("Merge extracted data with current state of database")

    articles = list(filter(lambda a: a.season_nr in map(lambda s: s.code, seasons), articles))

    data = [
        seasons,
        theme_groups,
        item_groups,
        colors,
        color_images,
        article_images,
        articles,
        article_details,
        price_lists,
        payment_terms,
        shipping_terms,
        partner,
        partner_agent_relation,
        sales_order_type_partner,
    ]

    for i, items in enumerate(data):
        for item in items:
            if not item: continue
            try:
                session.merge(item)
            except:
                print(f"{i}")

        session.commit()

    # update quantity of articles
    # update_quantities(session)

    # commit changes and close session
    session.close()

#run()