import json
from . import consts
from common.tools.comparison import cp


empty_str = ''


def get_pos_compare_info(pos_info):
    compare_info = {}

    application_entity = pos_info.get('applicationEntity', 'AFC')
    application_id = pos_info.get('applicationId', '')
    application_version = str(pos_info.get('applicationVersion', ''))
    first_submission_date = pos_info.get('firstSubmmisonDate', '')

    application_id_version = '{0}-{1}'.format(application_id, application_version)

    custr_name = custr_id = ''

    # 身份证
    role_count = 0
    individual_cus_info_list = pos_info.get('individualCusInfo', [])
    for individual_cus_info in individual_cus_info_list:
        role_count += 1
        customer_name = individual_cus_info.get('customerName', '').strip()
        id_num = individual_cus_info.get('idNum', '')
        applicant_type = individual_cus_info.get('applicantType', '')

        if applicant_type == 'CUSTR':
            custr_name = customer_name
            custr_id = id_num

        if individual_cus_info.get('idType', '') == consts.ID_TYPE:
            field_input = [(consts.ID_FIELDS[0], customer_name),
                           (consts.ID_FIELDS[1], id_num),
                           (consts.ID_FIELDS[2], individual_cus_info.get('idExpiryDate', ''))]
            compare_info.setdefault(consts.ID_EN, []).append(
                (consts.APPLICANT_TYPE_MAP.get(applicant_type, ''), field_input)
            )

    # 新车发票
    vehicle_info = pos_info.get('vehicleInfo', {})
    vin_no = vehicle_info.get('vinNo', '')
    amount = str(vehicle_info.get('vehicleTransactionAmount', '0.0'))
    field_input = [
        (consts.MVI_FIELDS[0], vin_no),
        (consts.MVI_FIELDS[1], amount),
        (consts.MVI_FIELDS[2], custr_name),
        (consts.MVI_FIELDS[3], custr_id),
        (consts.MVI_FIELDS[4], first_submission_date),
        (consts.MVI_FIELDS[5], consts.MVI_FPL_VALUE),
    ]
    compare_info.setdefault(consts.MVI_EN, []).append(field_input)

    # 银行卡
    bank_info = pos_info.get('bankInfo', {})
    bank_status = bank_info.get('bankVerificationStatus', '')
    account_no = bank_info.get('accountNo', '')
    bank_name = bank_info.get('bankName', '')
    account_holder_name = bank_info.get('accountHolderName', '')

    if bank_status != 'PASS':
        field_input = [
            (consts.BC_FIELDS[0], account_no),
            (consts.BC_FIELDS[1], bank_name),
            (consts.BC_FIELDS[2], consts.BC_TYPE_VALUE)  # 是否为借记卡
        ]
        compare_info.setdefault(consts.BC_EN, []).append(field_input)

    # 抵押登记豁免函
    quotationt_info = pos_info.get('quotationtInfo', {})
    if quotationt_info.get('mortgageType', '') == 'MOTGF':
        field_input = [
            (consts.HMH_FIELDS[0], custr_name),
            (consts.HMH_FIELDS[1], custr_id),
            (consts.HMH_FIELDS[2], application_id_version),
            # 宝马金融（中国）有限公司 先锋国际融资租赁有限公司
            (consts.HMH_FIELDS[3], consts.HMH_CHANNEL_MAP.get(application_entity, '')),
            (consts.HMH_FIELDS[4], consts.HAVE_CN),
        ]
        compare_info.setdefault(consts.HMH_EN, []).append(field_input)

    # 保单
    insurance_info = pos_info.get('insuranceInfo', {})
    if insurance_info.get('insuranceType') == 'ITCOM':
        field_input = [
            (consts.BD_FIELDS[0], [custr_name, ]),
            (consts.BD_FIELDS[1], [custr_id, ]),
            (consts.BD_FIELDS[2], vin_no)
        ]
        compare_info.setdefault(consts.BD_EN, []).append(field_input)

    # 合同准备项
    # 还款计划表
    schedule_list = []
    no_sort_tmp_list = quotationt_info.get('monthlyPaymentInfo', [])
    no_sort_tmp_list.sort(key=lambda x: x['term'])
    for schedule_dict in no_sort_tmp_list:
        tmp_str = "{1}{0}{2}".format(consts.SPLIT_STR, str(schedule_dict.get('term', '')),
                                     str(schedule_dict.get('amount', '')))
        schedule_list.append(tmp_str)
    schedule_list_str = consts.SCHEDULE_SPLIT_STR.join(schedule_list)

    # asp
    asp_list = []
    for asp_info in quotationt_info.get('associatedServiceInfo', []):
        asp_list.append(
            (
                asp_info.get('service', ''),
                str(asp_info.get('amount', '0.00')),
                str(asp_info.get('financedAmount', '0.00')),
            )
        )
    if len(asp_list) > 0:
        asp_list.append(
            (
                consts.ASP_SUM_NAME,
                '',
                str(quotationt_info.get('associatedServicePrincipal', 0)),
            )
        )

    # HIL合同
    if application_entity in consts.HIL_SET:
        # HIL合同  售后回租合同 --------------------------------------------------------------------------------------
        # ['合同编号-每页', '车辆识别代码', '还款计划表', '还款账号', '户名', '开户行', 'ASP项目详情']
        hil_contract_1_input = [
            (consts.HIL_CON_1_FIELDS[0], [application_id_version]),
            (consts.HIL_CON_1_FIELDS[1], vin_no),
            (consts.HIL_CON_1_FIELDS[2], schedule_list_str),
            (consts.HIL_CON_1_FIELDS[3], account_no),
            (consts.HIL_CON_1_FIELDS[4], account_holder_name),
            (consts.HIL_CON_1_FIELDS[5], bank_name),
        ]
        # asp各项
        if len(asp_list) > 0:
            hil_contract_1_input.append((consts.HIL_CON_1_FIELDS[6], asp_list))
        compare_info.setdefault(consts.HIL_CONTRACT_1_EN, []).append(hil_contract_1_input)

        # HIL合同  车辆租赁抵押合同 --------------------------------------------------------------------------------------
        # ['合同编号', '合同编号-正文', '车辆识别代码']
        hil_contract_2_input = [
            (consts.HIL_CON_2_FIELDS[0], application_id_version),
            (consts.HIL_CON_2_FIELDS[1], application_id_version),
            (consts.HIL_CON_2_FIELDS[2], vin_no),
        ]
        compare_info.setdefault(consts.HIL_CONTRACT_2_EN, []).append(hil_contract_2_input)

    # AFC合同
    else:
        # ['合同编号-每页', '合同编号-每页(no-asp)', '车架号-重要条款', '车架号', '还款账号', '户名', '开户行', '还款计划表',
        # 'ASP项目详情-重要条款', 'ASP项目详情', '见证人签字', '见证人日期']

        if len(asp_list) > 0:
            afc_contract_input = [
                (consts.AFC_CON_FIELDS[0], application_id_version),
            ]
        else:
            afc_contract_input = [
                (consts.AFC_CON_FIELDS[1], application_id_version),
            ]

        afc_contract_input.extend([
            (consts.AFC_CON_FIELDS[2], vin_no),
            (consts.AFC_CON_FIELDS[3], vin_no),
            (consts.AFC_CON_FIELDS[4], account_no),
            (consts.AFC_CON_FIELDS[5], account_holder_name),
            (consts.AFC_CON_FIELDS[6], bank_name),
            (consts.AFC_CON_FIELDS[7], schedule_list_str),
        ])

        if len(asp_list) > 0:
            # asp各项
            afc_contract_input.append((consts.AFC_CON_FIELDS[8], asp_list))
            afc_contract_input.append((consts.AFC_CON_FIELDS[9], asp_list))

        afc_contract_input.append((consts.AFC_CON_FIELDS[10], consts.HAVE_CN))
        afc_contract_input.append((consts.AFC_CON_FIELDS[11], empty_str))
        compare_info.setdefault(consts.AFC_CONTRACT_EN, []).append(afc_contract_input)

        afc_contract_qrs_input = [(consts.AFC_CON_QRS_FIELDS[0], '{0}{1}{2}'.format(role_count, consts.SPLIT_STR, application_id_version))]
        compare_info.setdefault(consts.AFC_CONTRACT_QRS_EN, []).append(afc_contract_qrs_input)

    return compare_info


def pre_compare_process(compare_info, ocr_res_dict, id_res_list):
    compare_result = {}
    for license_en, items_list in compare_info.items():
        if license_en == consts.ID_EN:
            for applicant_type, field_list in items_list:
                result_list = pre_compare_license_id(license_en, id_res_list, field_list, applicant_type)
                compare_result.setdefault(license_en, []).append(result_list)
        elif license_en in [consts.HIL_CONTRACT_1_EN, consts.HIL_CONTRACT_2_EN, consts.AFC_CONTRACT_EN]:
            for field_list in items_list:
                result_list = pre_compare_license_contract(license_en, ocr_res_dict, field_list)
                compare_result.setdefault(license_en, []).append(result_list)
        elif license_en == consts.AFC_CONTRACT_QRS_EN:
            for field_list in items_list:
                result_list = pre_compare_license_contract_qrs(license_en, ocr_res_dict, field_list)
                compare_result.setdefault(license_en, []).append(result_list)
        else:
            for field_list in items_list:
                result_list = pre_compare_license(license_en, ocr_res_dict, field_list)
                compare_result.setdefault(license_en, []).append(result_list)
    return compare_result


def pre_compare_license(license_en, ocr_res_dict, field_list):
    ocr_field, compare_logic, no_find_comment = consts.PRE_COMPARE_LOGIC_MAP[license_en]

    is_find = False
    result_field_list = []

    ocr_res_str = ocr_res_dict.get(ocr_field)
    if ocr_res_str is not None:
        ocr_res_list = json.loads(ocr_res_str)
        length = len(ocr_res_list)

        for res_idx in range(length-1, -1, -1):
            if is_find:
                break

            for idx, (name, value) in enumerate(field_list):
                ocr_str = ocr_res_list[res_idx].get(compare_logic[name][0])

                if isinstance(ocr_str, str):
                    result = getattr(cp, compare_logic[name][1])(value, ocr_str, **compare_logic[name][2])
                else:
                    result = consts.RESULT_N
                    ocr_str = empty_str

                if idx == 0 and result == consts.RESULT_N and length > 1:
                    break

                is_find = True

                if isinstance(value, list):
                    value = json.dumps(value, ensure_ascii=False)
                result_field_list.append((value, ocr_str, result, compare_logic[name][3]))

    if not is_find:
        result_field_list.append((empty_str, empty_str, consts.RESULT_N, no_find_comment))

    return result_field_list


def pre_compare_license_id(license_en, id_res_list, field_list, applicant_type):
    ocr_field, compare_logic, no_find_comment = consts.PRE_COMPARE_LOGIC_MAP[license_en]

    is_find = False
    result_field_list = []
    field_last_idx = len(field_list) - 1

    for ca_or_se_idx, ocr_res_str in enumerate(id_res_list):
        if is_find:
            break

        if ocr_res_str is not None:
            ocr_res_list = json.loads(ocr_res_str)
            length = len(ocr_res_list)

            # 身份证、居住证 过期期限特殊处理
            expiry_dates = set()
            key = compare_logic.get(consts.ID_FIELDS[2])[0]
            for ocr_res in ocr_res_list:
                if key in ocr_res:
                    expiry_dates.add(ocr_res[key])

            for res_idx in range(length-1, -1, -1):
                if is_find:
                    break

                result_field_list.clear()
                for idx, (name, value) in enumerate(field_list):
                    ocr_str = ocr_res_list[res_idx].get(compare_logic[name][0])
                    if not isinstance(ocr_str, str):
                        result = consts.RESULT_N
                        ocr_str = empty_str
                    else:
                        result = getattr(cp, compare_logic[name][1])(value, ocr_str, **compare_logic[name][2])

                    if idx == 0 and result == consts.RESULT_N:
                        if ca_or_se_idx == 0:
                            break
                        elif length > 1:
                            break

                    # 过期期限特殊处理
                    # N, N1, N2, Y
                    if name == consts.ID_FIELDS[2] and result == consts.RESULT_N:  # 遍历所有背面过期时间
                        if len(expiry_dates) == 0:
                            result = consts.RESULT_N1
                            ocr_str = empty_str
                        else:
                            tmp_res_set = set()
                            for expiry_date in expiry_dates:
                                expiry_date_res = getattr(cp, compare_logic[name][1])(value, expiry_date,
                                                                                      **compare_logic[name][2])
                                tmp_res_set.add(expiry_date_res)
                                if expiry_date_res == consts.RESULT_N1:
                                    result = expiry_date_res
                                    ocr_str = expiry_date
                                    break
                            else:
                                ocr_str = empty_str
                                if consts.RESULT_N2 in tmp_res_set:
                                    result = consts.RESULT_N2
                                else:
                                    result = consts.RESULT_Y

                    if ca_or_se_idx == 0:
                        if name == consts.ID_FIELDS[2]:
                            if result == consts.RESULT_N or result == consts.RESULT_N1:
                                break
                        elif result == consts.RESULT_N:
                            break

                    if ca_or_se_idx == 1:
                        is_find = True
                    elif idx == field_last_idx:
                        is_find = True

                    if isinstance(value, list):
                        value = json.dumps(value, ensure_ascii=False)

                    comments = consts.ID_DATE_MAP[result] if name == consts.ID_FIELDS[2] else compare_logic[name][3]
                    result_field_list.append((value, ocr_str, result, '{0}{1}'.format(applicant_type, comments)))

    if not is_find:
        result_field_list = [(empty_str, empty_str, consts.RESULT_N, no_find_comment.format(applicant_type))]

    return result_field_list


def pre_compare_license_contract(license_en, ocr_res_dict, field_list):
    ocr_field, compare_logic, no_find_comment = consts.PRE_COMPARE_LOGIC_MAP[license_en]

    result_field_list = []

    ocr_res_str = ocr_res_dict.get(ocr_field)
    if ocr_res_str is not None:
        ocr_res_list = json.loads(ocr_res_str)
        ocr_res = ocr_res_list.pop()

        for name, value in field_list:
            ocr_str_or_list = ocr_res.get(compare_logic[name][0])

            # 见证人日期
            if name == consts.AFC_CON_FIELDS[11]:
                if not isinstance(ocr_str_or_list, str) or len(ocr_str_or_list) == 0:
                    result = consts.RESULT_N
                    ocr_str = empty_str
                else:
                    is_find_date = False
                    all_date_list = [ocr_str_or_list]
                    for date_name in consts.AFC_HT_DATE_FIELDS:
                        all_date_list.append(ocr_res.get(compare_logic[date_name][0], ''))
                        if not is_find_date and ocr_str_or_list == ocr_res.get(compare_logic[date_name][0], ''):
                            is_find_date = True
                    result = consts.RESULT_Y if is_find_date else consts.RESULT_N
                    ocr_str = json.dumps(all_date_list, ensure_ascii=False)
            elif isinstance(ocr_str_or_list, str) or isinstance(ocr_str_or_list, list):
                if isinstance(ocr_str_or_list, list):
                    # no-asp 合同编号-每页(no-asp)
                    if name == consts.AFC_CON_FIELDS[1]:
                        ocr_str_or_list.pop()
                    ocr_str = json.dumps(ocr_str_or_list, ensure_ascii=False)
                else:
                    ocr_str_or_list = ocr_str_or_list.strip()
                    ocr_str = ocr_str_or_list
                result = getattr(cp, compare_logic[name][1])(value, ocr_str_or_list, **compare_logic[name][2])
            else:
                result = consts.RESULT_N
                ocr_str = empty_str

            comments = compare_logic[name][3]
            if isinstance(value, list):
                value = json.dumps(value, ensure_ascii=False)
            result_field_list.append((value, ocr_str, result, comments))
    else:
        result_field_list.append((empty_str, empty_str, consts.RESULT_N, no_find_comment))

    return result_field_list


def pre_compare_license_contract_qrs(license_en, ocr_res_dict, field_list):
    ocr_field, compare_logic, no_find_comment = consts.PRE_COMPARE_LOGIC_MAP[license_en]
    ocr_res_str = ocr_res_dict.get(ocr_field)

    result_field_list = []

    if ocr_res_str is not None:
        ocr_res_list = json.loads(ocr_res_str)

        contract_num_list = []
        for qrs_res in ocr_res_list:
            contract_num_list.append(qrs_res.get('合同编号', ''))

        ocr_res = {
            '合同编号': contract_num_list
        }

        for name, value in field_list:
           
            ocr_str_or_list = ocr_res.get(compare_logic[name][0])

            if isinstance(ocr_str_or_list, list):
                ocr_str = json.dumps(ocr_str_or_list, ensure_ascii=False)
            else:
                ocr_str_or_list = ocr_str_or_list.strip()
                ocr_str = ocr_str_or_list
            result = getattr(cp, compare_logic[name][1])(value, ocr_str_or_list, **compare_logic[name][2])

            comments = compare_logic[name][3]
            result_field_list.append((value, ocr_str, result, comments))
    else:
        result_field_list.append((empty_str, empty_str, consts.RESULT_Y, no_find_comment))

    return result_field_list


def rebuild_result(compare_result):
    # compare_result = {
    #     "is_pass": True,
    #     "particulars": [{
    #         "object_name": "PRC ID",
    #         "fields": [{
    #             "input": "张三",
    #             "ocr": "张三",
    #             "field_is_pass": True,
    #             "comments": "身份证姓名与系统不一致"
    #         }]
    #     }]
    # }
    is_pass = True
    particulars_list = []
    for license_en, items_list in compare_result.items():
        for result_field_list in items_list:
            field_list = []
            for input_str, ocr_str, result, comments in result_field_list:
                if result != consts.RESULT_Y:
                    is_pass = False
                field_list.append(
                    {
                        'input': input_str,
                        'ocr': ocr_str,
                        'field_is_pass': result == consts.RESULT_Y,
                        'comments': comments,
                    }
                )
            particulars_list.append(
                {
                    'object_name': license_en,
                    'fields': field_list
                }
            )
    rebuild_compare_result = {
        'is_pass': is_pass,
        'particulars': particulars_list
    }
    return rebuild_compare_result


def pre_compare(pos_info, ocr_res_dict, id_res_list):
    compare_info = get_pos_compare_info(pos_info)
    compare_result = pre_compare_process(compare_info, ocr_res_dict, id_res_list)
    rebuild_compare_result = rebuild_result(compare_result)
    return rebuild_compare_result


def get_empty_result():
    empty_result = {
        "is_pass": False,
        "particulars": [{
            "object_name": "",
            "fields": [{
                "input": "",
                "ocr": "",
                "field_is_pass": False,
                "comments": "预放款结果超时未返回，请直接提交放款"
            }]
        }]
    }
    return empty_result