import sys

if "/service_account_records" not in list(sys.path):
    sys.path.append("/service_account_records")

from decimal import Decimal

from api_services.bank_actions.wag_account_record_parser import (
    parse_comment_with_name,
    parse_comment_with_name_iban_description,
)
from databases import (
    AccountRecords,
    BuildIbans,
    BuildDecisionBook,
    Build,
    BuildLivingSpace,
    People,
    OccupantTypes,
)
from api_validations.validations_request import ListOptions
from api_library.date_time_actions.date_functions import system_arrow
from databases.sql_models.building.build import BuildParts
from databases.sql_models.building.decision_book import BuildDecisionBookPayments
from databases.sql_models.others.enums import ApiEnumDropdown


account_list = ListOptions(
    page=1,
    size=1000,
    order_field="bank_date",
    order_type="desc",
)


def account_records_find_decision_book():
    created_ibans, iban_build_dict = [], {}
    AccountRecords.filter_attr = account_list
    account_records_list: list[AccountRecords] = AccountRecords.filter_all(
        AccountRecords.build_decision_book_id == None,
        AccountRecords.remainder_balance < AccountRecords.currency_value,
        system=True,
    ).data
    for account_record in account_records_list:
        if account_record.iban not in created_ibans:
            found_iban: BuildIbans = BuildIbans.filter_one(
                BuildIbans.iban == account_record.iban, system=True
            ).data
            if not found_iban:
                try:
                    create_build_ibans = BuildIbans.find_or_create(
                        iban=account_record.iban,
                        start_date=str(system_arrow.now().shift(days=-1)),
                    )
                    create_build_ibans.save_and_confirm()
                    created_ibans.append(account_record.iban)
                except Exception as e:
                    print("Exception of find_decision_book ln:55", e)
            if not getattr(found_iban, 'build_id', None):  # It is in database already
                iban_build_dict["iban"] = account_record.iban
                iban_build_dict["build_id"] = None
            else:
                found_decision_book = BuildDecisionBook.filter_one(
                    BuildDecisionBook.build_id == found_iban.build_id,
                    BuildDecisionBook.expiry_starts <= account_record.bank_date,
                    BuildDecisionBook.expiry_ends > account_record.bank_date,
                ).data
                if found_decision_book:
                    account_record.update(
                        build_decision_book_id=found_decision_book.id,
                        build_decision_book_uu_id=str(found_decision_book.uu_id),
                        build_id=found_decision_book.build_id,
                        build_uu_id=str(found_decision_book.build_uu_id),
                    )
                    account_record.save()
    return


def account_save_search_result(account_record, similarity_result):
    found_company = similarity_result.get("company", None)
    found_customer, part, build = (
        similarity_result.get("living_space", None),
        None,
        None,
    )
    if found_customer:
        part = BuildParts.filter_by_one(
            id=found_customer.build_parts_id, human_livable=True
        ).data
    if part:
        build = Build.filter_by_one(id=part.build_id).data

    account_record.similarity = similarity_result.get("similarity", 0.00)
    account_record.found_from = similarity_result.get("found_from", None)
    account_record.company_id = getattr(found_company, "id", None)
    account_record.company_uu_id = getattr(found_company, "uu_id", None)
    account_record.build_parts_id = getattr(part, "id", None)
    account_record.build_parts_uu_id = getattr(part, "uu_id", None)

    if not account_record.build_id and build:
        account_record.build_id = getattr(build, "id", None)
        account_record.build_uu_id = getattr(build, "uu_id", None)

    # account_record.send_person_id = getattr(found_send_person, "id", None)
    # account_record.send_person_uu_id = getattr(found_send_person, "uu_id", None)
    account_record.living_space_id = getattr(found_customer, "id", None)
    account_record.living_space_uu_id = getattr(found_customer, "uu_id", None)
    account_record.save()


def account_get_people_and_living_space_info_via_iban() -> dict:
    build_living_space_dict = {}
    account_records_ibans = (
        AccountRecords.select_only(
            AccountRecords.build_decision_book_id != None,
            select_args=[AccountRecords.iban],
            system=True,
        )
        .query.distinct(AccountRecords.iban)
        .all()
    )
    flat_resident = OccupantTypes.filter_by_one(
        system=True, occupant_category_type="FL", occupant_code="FL-RES"
    ).data
    flat_owner = OccupantTypes.filter_by_one(
        system=True, occupant_category_type="FL", occupant_code="FL-OWN"
    ).data
    flat_tenant = OccupantTypes.filter_by_one(
        system=True, occupant_category_type="FL", occupant_code="FL-TEN"
    ).data
    flat_represent = OccupantTypes.filter_by_one(
        system=True, occupant_category_type="FL", occupant_code="FL-REP"
    ).data
    for account_records_iban in account_records_ibans:
        if account_records_iban not in build_living_space_dict:
            build_iban: BuildIbans = BuildIbans.filter_one(
                BuildIbans.iban == account_records_iban[0], system=True
            ).data
            build_parts = BuildParts.filter_by_all(
                system=True, build_id=build_iban.build_id, human_livable=True
            ).data
            living_spaces = BuildLivingSpace.filter_all(
                BuildLivingSpace.build_parts_id.in_(
                    [build_parts.id for build_parts in build_parts]
                ),
                BuildLivingSpace.occupant_type.in_(
                    [flat_resident.id, flat_owner.id, flat_tenant.id, flat_represent.id]
                ),
            ).data
            living_spaces_people = [
                living_space.person_id
                for living_space in living_spaces
                if living_space.person_id
            ]
            people_list = People.filter_all(
                People.id.in_(living_spaces_people), system=True
            ).data
            print("build_parts", build_parts)
            build_living_space_dict[str(account_records_iban[0])] = {
                "people": list(people_list),
                "living_space": list(living_spaces),
                "build_parts": list(build_parts),
            }
    return build_living_space_dict


def account_records_search():
    build_living_space_dict = account_get_people_and_living_space_info_via_iban()
    AccountRecords.filter_attr, found_list = account_list, []
    account_records_list: list[AccountRecords] = AccountRecords.filter_all(
        # AccountRecords.build_decision_book_id != None, system=True
    ).data
    for account_record in account_records_list:
        similarity_result = parse_comment_with_name(
            account_record=account_record, living_space_dict=build_living_space_dict
        )
        fs, ac = similarity_result.get("similarity"), account_record.similarity or 0
        if float(fs) >= 0.8 and float(fs) > float(ac):
            found_list.append(similarity_result)
            account_save_search_result(
                account_record=account_record, similarity_result=similarity_result
            )
        else:
            similarity_result = parse_comment_with_name_iban_description(
                account_record=account_record
            )
            fs, ac = similarity_result.get("similarity"), account_record.similarity or 0
            if float(fs) >= 0.8 and float(fs) > float(ac):
                found_list.append(similarity_result)
                account_save_search_result(
                    account_record=account_record, similarity_result=similarity_result
                )
    print("Account Records Search : ", len(found_list), "/", len(account_records_list))
    return


def pay_the_registration(
    account_record, receive_enum, debit_enum, is_old_record: bool = False
):
    current_currency_value = float(Decimal(account_record.currency_value)) - float(
        Decimal(account_record.remainder_balance)
    )
    if not current_currency_value > 0:
        return current_currency_value

    process_date = system_arrow.get(account_record.bank_date)
    account_bank_date_year, account_bank_date_month = (
        process_date.date().year,
        process_date.date().month,
    )
    payment_arguments_debit = [
        BuildDecisionBookPayments.build_parts_id == account_record.build_parts_id,
        BuildDecisionBookPayments.payment_types_id == debit_enum.id,
        BuildDecisionBookPayments.account_records_id == None,
    ]
    if not is_old_record:
        payment_arguments_debit.extend(
            [
                BuildDecisionBookPayments.process_date_y == int(account_bank_date_year),
                BuildDecisionBookPayments.process_date_m
                == int(account_bank_date_month),
            ]
        )
    payments = (
        BuildDecisionBookPayments.filter_all(*payment_arguments_debit)
        .query.order_by(BuildDecisionBookPayments.process_date.asc())
        .all()
    )
    for payment in payments:
        if not current_currency_value > 0:
            return current_currency_value

        payment_arguments_receive = [
            BuildDecisionBookPayments.build_parts_id == account_record.build_parts_id,
            BuildDecisionBookPayments.payment_plan_time_periods
            == payment.payment_plan_time_periods,
            BuildDecisionBookPayments.payment_types_id == receive_enum.id,
            BuildDecisionBookPayments.build_decision_book_item_id
            == payment.build_decision_book_item_id,
            BuildDecisionBookPayments.decision_book_project_id
            == payment.decision_book_project_id,
            BuildDecisionBookPayments.process_date == payment.process_date,
        ]
        if not is_old_record:
            payment_arguments_receive.extend(
                [
                    BuildDecisionBookPayments.process_date_y
                    == int(account_bank_date_year),
                    BuildDecisionBookPayments.process_date_m
                    == int(account_bank_date_month),
                ]
            )

        payment_received = (
            BuildDecisionBookPayments.filter_all(*payment_arguments_receive).data or []
        )
        sum_of_payment_received = sum(
            [abs(payment.payment_amount) for payment in payment_received]
        )
        net_amount = float(abs(Decimal(payment.payment_amount))) - float(
            abs(Decimal(sum_of_payment_received))
        )
        if not net_amount > 0:
            continue
        if float(abs(current_currency_value)) < float(abs(net_amount)):
            net_amount = float(current_currency_value)
        process_date = system_arrow.get(payment.process_date)
        try:
            created_book_payment = BuildDecisionBookPayments.find_or_create(
                payment_plan_time_periods=payment.payment_plan_time_periods,
                payment_amount=float(abs(net_amount)),
                payment_types_id=receive_enum.id,
                payment_types_uu_id=str(receive_enum.uu_id),
                process_date=str(process_date),
                process_date_m=process_date.date().month,
                process_date_y=process_date.date().year,
                period_time=f"{process_date.year}-{str(process_date.month).zfill(2)}",
                build_parts_id=payment.build_parts_id,
                build_parts_uu_id=str(payment.build_parts_uu_id),
                account_records_id=account_record.id,
                account_records_uu_id=str(account_record.uu_id),
                build_decision_book_item_id=payment.build_decision_book_item_id,
                build_decision_book_item_uu_id=str(
                    payment.build_decision_book_item_uu_id
                ),
                decision_book_project_id=payment.decision_book_project_id,
                decision_book_project_uu_id=str(payment.decision_book_project_uu_id),
            )
            created_book_payment.save_and_confirm()
            created_payment_amount = float(Decimal(created_book_payment.payment_amount))
            remainder_balance = float(
                Decimal(account_record.remainder_balance)
            ) + float(abs(created_payment_amount))
            account_record.update(remainder_balance=remainder_balance)
            account_record.save()
            if current_currency_value >= abs(net_amount):
                current_currency_value -= abs(net_amount)
        except Exception as e:
            print("Exception of decision payment ln:300", e)
    return current_currency_value


def send_accounts_to_decision_payment():
    AccountRecords.filter_attr = account_list
    receive_enum = ApiEnumDropdown.filter_by_one(
        system=True, enum_class="DebitTypes", key="DT-R"
    ).data
    debit_enum = ApiEnumDropdown.filter_by_one(
        system=True, enum_class="DebitTypes", key="DT-D"
    ).data
    account_records_list: list[AccountRecords] = AccountRecords.filter_all(
        AccountRecords.remainder_balance < AccountRecords.currency_value,
        AccountRecords.approved_record == True,
        AccountRecords.receive_debit == receive_enum.id,
    ).data
    for account_record in account_records_list:
        current_currency_value = pay_the_registration(
            account_record, receive_enum, debit_enum
        )
        if current_currency_value > 0:
            pay_the_registration(account_record, receive_enum, debit_enum, True)
        if abs(float(Decimal(account_record.remainder_balance))) == abs(
            float(Decimal(account_record.currency_value))
        ):
            account_record.update(status_id=97)
            account_record.save()
        # # # todo If the payment is more than the amount, then create a new account record with the remaining amount
    return


def account_records_service() -> None:
    print('Account Records Service is running...')
    account_records_find_decision_book()
    account_records_search()
    send_accounts_to_decision_payment()
    print('Account Records Service is finished...')
    return


if __name__ == "__main__":
    account_records_service()