/**
 * 数量 保留15位数字
 * 单价 保留15位数字
 * 金额 小数点后 2位
 * 税额 小数点后 2位
 */
import { WrappedFormUtils } from 'kts-components-antd-x3/lib/form/Form';
import InvoiceController, { IGood, LineAttributeType } from '../../../../../../InvoiceController';
import evaluate from '../../../../../../tools/evaluate';
import { message } from 'kts-components-antd-x3'
import { format2, format15, countTaxAmount, countAmountExcludeTax, countPrice } from '../../../../../../tools/calculate';
import moment from 'moment';
import { equal } from 'mathjs';

export { format2, format15 } from '../../../../../../tools/calculate';

/** 延迟函数 */
const lazyFn = (fn: Function, delayed: number = 200) => {
  let timer: any;
  return (...par: any[]) => {
    clearTimeout(timer);
    timer = setTimeout(() => {
      timer = undefined;
      fn.apply(null, par);
    }, delayed);
  };
};

let promptErrV: any = {}

/** 提示错误 */
const promptErr = (err: any) => {
  if (!err) return false;
  if (err.errors[0].message === 'lineAmountIncludeTax need to revalidate') return true;
  if (err.errors[0].message === 'lineAmountExcludeTax need to revalidate') return true;
  if (err.errors[0].message === 'priceIncludeTax need to revalidate') return true;
  if (err.errors[0].message === 'priceExcludeTax need to revalidate') return true;

  if (new Date().getTime() - promptErrV.t > 2000 || err.errors[0].message !== promptErrV.m) {
    promptErrV.t = new Date().getTime();
    promptErrV.m = err.errors[0].message;
    message.error({ content: err.errors[0].message, duration: 2 });
  }

  return true;
}

/** 清除计算中启动字段 */
export const clearCalculatingField = async (controller: InvoiceController) => controller.run(async s => s.calculatingField = '');

/** 数量改变了 */
// export const onChangeQuantity = lazyFn(
//   (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
//     form.validateFields(async (err, values) => {
//       err = err || {};

//       if (!values.quantity && values.quantity !== 0) {
//         await controller.setEditGood({ quantity: undefined });
//         await clearCalculatingField(controller);
//         return;
//       }
//       if (err.quantity) {
//         await clearCalculatingField(controller);
//         return
//       };

//       const calculatingDigits = controller.state.calculatingDigits;
//       const quantity = format15(values.quantity, calculatingDigits);
//       await controller.setEditGood({ quantity });
//       form.setFieldsValue({ quantity });

//       // 是否含税
//       if (controller.state.goodsListState.isTaxIncluded) {
//         // 含税
//         if (!err.priceIncludeTax && values.priceIncludeTax) {
//           // 可以找到 单价(含税)
//           const priceIncludeTax = format15(values.priceIncludeTax, calculatingDigits);
//           const lineAmountIncludeTax = format2(evaluate(`${priceIncludeTax} * ${quantity}`));
//           form.setFieldsValue({ lineAmountIncludeTax });
//           await controller.setEditGood({ lineAmountIncludeTax });
//         } else if (!err.lineAmountIncludeTax && values.lineAmountIncludeTax) {
//           // 可以找到 金额(含税)
//           const lineAmountIncludeTax = format2(values.lineAmountIncludeTax);
//           const priceIncludeTax = format15(
//             evaluate(`${lineAmountIncludeTax} / ${quantity}`),
//             calculatingDigits);
//           form.setFieldsValue({ priceIncludeTax });
//           await controller.setEditGood({ priceIncludeTax });
//         }

//         // 更新不含税
//         await updateUnitPriceExcludingTax(controller, form, record);
//       } else {
//         // 不含税
//         if (!err.priceExcludeTax && values.priceExcludeTax) {
//           const priceExcludeTax = format15(values.priceExcludeTax, calculatingDigits);
//           const lineAmountExcludeTax = format2(evaluate(`${quantity} * ${priceExcludeTax}`));
//           form.setFieldsValue({ lineAmountExcludeTax });
//           await controller.setEditGood({ lineAmountExcludeTax, quantity });
//         } else if (!err.lineAmountExcludeTax && values.lineAmountExcludeTax) {
//           const lineAmountExcludeTax = format2(values.lineAmountExcludeTax);
//           const priceExcludeTax = format15(evaluate(`${lineAmountExcludeTax} / ${quantity}`), calculatingDigits);
//           form.setFieldsValue({ priceExcludeTax });
//           await controller.setEditGood({ priceExcludeTax, quantity });
//         }

//         // 更新含税
//         await updateUnitPriceTax(controller, form, record);
//       }

//       // 清楚 计算中启动字段
//       await clearCalculatingField(controller);
//     });
//   },
//   1000,
// );
export const onChangeQuantity = lazyFn(
  (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
    form.validateFields(async (err, values) => {
      err = err || {};

      if (!values.quantity && values.quantity !== 0) {
        await controller.setEditGood({ quantity: undefined });
        await clearCalculatingField(controller);
        return;
      }
      if (err.quantity) {
        await clearCalculatingField(controller);
        return;
      }

      const calculatingDigits = controller.state.calculatingDigits;
      const quantity = format15(values.quantity, calculatingDigits);
      await controller.setEditGood({ quantity });
      form.setFieldsValue({ quantity });

      // 是否含税
      if (controller.state.goodsListState.isTaxIncluded) {
        // 含税：只根据金额反算单价
        if (!err.lineAmountIncludeTax && values.lineAmountIncludeTax) {
          const lineAmountIncludeTax = format2(values.lineAmountIncludeTax);
          const priceIncludeTax = format15(
            evaluate(`${lineAmountIncludeTax} / ${quantity}`),
            8
          );
          form.setFieldsValue({ priceIncludeTax });
          await controller.setEditGood({ priceIncludeTax });
        }

        // 更新不含税单价（反算）
        await updateUnitPriceExcludingTax(controller, form, record);

      } else {
        // 不含税：只根据金额反算单价
        if (!err.lineAmountExcludeTax && values.lineAmountExcludeTax) {
          const lineAmountExcludeTax = format2(values.lineAmountExcludeTax);
          const priceExcludeTax = format15(
            evaluate(`${lineAmountExcludeTax} / ${quantity}`),
            8
          );
          form.setFieldsValue({ priceExcludeTax });
          await controller.setEditGood({ priceExcludeTax });
        }

        // 更新含税单价（反算）
        await updateUnitPriceTax(controller, form, record);
      }

      await clearCalculatingField(controller);
    });
  },
  1000,
);
/** 单价(含税) */
export const onChangePriceIncludeTax = lazyFn(
  (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
    form.validateFields(async (err, values) => {
      err = err || {};

      if (!values.priceIncludeTax && values.priceIncludeTax !== 0) {
        await controller.setEditGood({ priceIncludeTax: undefined, priceExcludeTax: undefined });
        await clearCalculatingField(controller);
        return;
      }
      if (err.priceIncludeTax) {
        await clearCalculatingField(controller);
        return;
      }

      const calculatingDigits = controller.state.calculatingDigits;
      const priceIncludeTax = format15(values.priceIncludeTax, 8);
      await controller.setEditGood({ priceIncludeTax });
      form.setFieldsValue({ priceIncludeTax });

      // 是否有数量
      if (!err.quantity && values.quantity) {
        const quantity = format15(values.quantity, calculatingDigits);
        const lineAmountIncludeTax = format2(evaluate(`${quantity} * ${priceIncludeTax}`));
        form.setFieldsValue({ lineAmountIncludeTax });
        await controller.setEditGood({ lineAmountIncludeTax });
      } else if (!err.lineAmountIncludeTax && values.lineAmountIncludeTax) {
        const lineAmountIncludeTax = format2(values.lineAmountIncludeTax);
        const quantity = format15(evaluate(`${lineAmountIncludeTax} / ${priceIncludeTax}`), calculatingDigits);
        form.setFieldsValue({ quantity });
        await controller.setEditGood({ quantity });
      }

      // 更新不含税
      await updateUnitPriceExcludingTax(controller, form, record);

      // 清楚 计算中启动字段
      await clearCalculatingField(controller);
    });
  },
  1000,
);

/** 单价(不含税) */
export const onChangePriceExcludeTax = lazyFn(
  (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
    form.validateFields(async (err, values) => {
      err = err || {};

      if (!values.priceExcludeTax && values.priceExcludeTax !== 0) {
        await controller.setEditGood({ priceIncludeTax: undefined, priceExcludeTax: undefined });
        await clearCalculatingField(controller);
        return;
      }
      if (err.priceExcludeTax) {
        await clearCalculatingField(controller);
        return;
      }

      const calculatingDigits = controller.state.calculatingDigits;
      const priceExcludeTax = format15(values.priceExcludeTax, 8);
      await controller.setEditGood({ priceExcludeTax });
      form.setFieldsValue({ priceExcludeTax });

      // 是否有数量
      if (!err.quantity && values.quantity) {
        const quantity = format15(values.quantity, calculatingDigits);
        const lineAmountExcludeTax = format2(evaluate(`${quantity} * ${priceExcludeTax}`));
        form.setFieldsValue({ lineAmountExcludeTax });
        await controller.setEditGood({ lineAmountExcludeTax });
      } else if (!err.lineAmountExcludeTax && values.lineAmountExcludeTax) {
        const lineAmountExcludeTax = format2(values.lineAmountExcludeTax);
        const quantity = format15(
          evaluate(`${lineAmountExcludeTax} / ${priceExcludeTax}`),
          calculatingDigits
        );
        form.setFieldsValue({ quantity });
        await controller.setEditGood({ quantity });
      }

      // 更新含税
      await updateUnitPriceTax(controller, form, record);

      // 清楚 计算中启动字段
      await clearCalculatingField(controller);
    });
  },
  1000,
);

/** 金额(含税) */
export const onChangeLineAmountIncludeTax = lazyFn(
  (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
    form.validateFields(async (err, values) => {

      err = err || {};
      if (promptErr(err.lineAmountIncludeTax) || !values.lineAmountIncludeTax) {
        // 更新不含税
        await controller.setEditGood({ lineAmountIncludeTax: undefined, lineAmountExcludeTax: undefined });
        await updateUnitPriceExcludingTax(controller, form, record);
        await clearCalculatingField(controller);
        return;
      }

      const calculatingDigits = controller.state.calculatingDigits;
      const lineAmountIncludeTax = format2(values.lineAmountIncludeTax);
      await controller.setEditGood({ lineAmountIncludeTax });
      form.setFieldsValue({ lineAmountIncludeTax });

      // 是否有数量
      if (!err.quantity && values.quantity) {
        const quantity = format15(values.quantity, calculatingDigits);
        const priceIncludeTax = format15(evaluate(`${lineAmountIncludeTax} / ${quantity}`), 8);
        form.setFieldsValue({ priceIncludeTax });
        await controller.setEditGood({ priceIncludeTax });
      } else if (!err.priceIncludeTax && (values.priceIncludeTax || values.priceIncludeTax === 0)) {
        const priceIncludeTax = format15(values.priceIncludeTax, 8);
        const quantity = format15(evaluate(`${lineAmountIncludeTax} / ${priceIncludeTax}`), calculatingDigits);
        form.setFieldsValue({ quantity });
        await controller.setEditGood({ quantity });
      }

      // 更新不含税
      await updateUnitPriceExcludingTax(controller, form, record);

      // 清楚 计算中启动字段
      await clearCalculatingField(controller);
    });
  },
  1000,
);

/** 金额(不含税) */
export const onChangeLineAmountExcludeTax = lazyFn(
  (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
    form.validateFields(async (err, values) => {
      err = err || {};
      if (promptErr(err.lineAmountExcludeTax) || !values.lineAmountExcludeTax) {
        // 更新含税
        await controller.setEditGood({ lineAmountIncludeTax: undefined, lineAmountExcludeTax: undefined });
        await updateUnitPriceTax(controller, form, record);
        await clearCalculatingField(controller);
        return;
      }
      const calculatingDigits = controller.state.calculatingDigits;
      const lineAmountExcludeTax = format2(values.lineAmountExcludeTax);
      await controller.setEditGood({ lineAmountExcludeTax });
      form.setFieldsValue({ lineAmountExcludeTax });

      // 是否有数量
      if (!err.quantity && values.quantity) {
        const quantity = format15(values.quantity, calculatingDigits);
        const priceExcludeTax = format15(evaluate(`${lineAmountExcludeTax} / ${quantity}`), 8);
        form.setFieldsValue({ priceExcludeTax });
        await controller.setEditGood({ priceExcludeTax });
      } else if (!err.priceExcludeTax && values.priceExcludeTax) {
        const priceExcludeTax = format15(values.priceExcludeTax, 8);
        const quantity = format15(evaluate(`${lineAmountExcludeTax} / ${priceExcludeTax}`), calculatingDigits);
        form.setFieldsValue({ quantity });
        await controller.setEditGood({ quantity });
      }

      // 更新含税
      await updateUnitPriceTax(controller, form, record);

      // 清楚 计算中启动字段
      await clearCalculatingField(controller);
    });
  },
  1000,
);

/** 税率 */
export const onChangeTaxRate = lazyFn(
  (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {

    form.validateFields(async (err, values) => {
      err = err || {};
      if (promptErr(err.taxRate) || (!values.taxRate && values.taxRate !== 0)) return;

      let taxRate = parseFloat(values.taxRate);
      await controller.setEditGood({ taxRate });

      // 去掉赋码
      (() => {
        const cache = controller.state.goodsListState.endowCode.cache;
        const record = controller.state.goodsListState.editGood;
        if (record && cache[record.$index]) {
          record.favouredPolicyName = cache[record.$index].favouredPolicyName;
          record.favouredPolicyMark = cache[record.$index].favouredPolicyMark;
          record.taxFreeType = cache[record.$index].taxFreeType;
          cache[record.$index] = undefined;
        }
      })()

      switch (controller.state.goodsListState.calculateType) {
        case '1':
          await updateUnitPriceExcludingTax(controller, form, record);
          break;

        case '2':
          await updateUnitPriceTax(controller, form, record);
          break;

        case '3':
        default:
          // 是否含税
          if (controller.state.goodsListState.isTaxIncluded) {
            await updateUnitPriceExcludingTax(controller, form, record);
          } else {
            await updateUnitPriceTax(controller, form, record);
          }
          break;
      }

      // 清楚 计算中启动字段
      await clearCalculatingField(controller);
    });
  },
  1000,
);

/** 税额 */
export const onChangeTaxAmount = lazyFn(
  (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
    form.validateFields(async (err, values) => {
      err = err || {};
      
      if (!values.taxAmount && values.taxAmount !== 0) {
        await clearCalculatingField(controller);
        return;
      }

      const { editGood } = controller.state.goodsListState;
      const isTaxIncluded = controller.state.goodsListState.isTaxIncluded;
      const calculatingDigits = controller.state.calculatingDigits;
      const taxAmount = format2(values.taxAmount) as number;
      
      if (taxAmount === undefined || isNaN(taxAmount)) {
        await clearCalculatingField(controller);
        return;
      }
      
      await controller.setEditGood({ taxAmount });
      form.setFieldsValue({ taxAmount });

      if (isTaxIncluded) {
        // 含税模式：根据含税金额和税额计算不含税金额
        const lineAmountIncludeTax = values.lineAmountIncludeTax || editGood?.lineAmountIncludeTax;
        if ((lineAmountIncludeTax || lineAmountIncludeTax === 0) && taxAmount !== undefined) {
          const lineAmountExcludeTax = countAmountExcludeTax(lineAmountIncludeTax, taxAmount);
          if (lineAmountExcludeTax !== undefined) {
            form.setFieldsValue({ lineAmountExcludeTax });
            await controller.setEditGood({ lineAmountExcludeTax });

            // 更新不含税单价
            const quantity = values.quantity || editGood?.quantity;
            if (quantity || quantity === 0) {
              const priceExcludeTax = countPrice(lineAmountExcludeTax, quantity, calculatingDigits);
              if (priceExcludeTax !== undefined && priceExcludeTax !== '') {
                form.setFieldsValue({ priceExcludeTax });
                await controller.setEditGood({ priceExcludeTax });
              }
            }
          }
        }
      } else {
        // 不含税模式：根据不含税金额和税额计算含税金额
        const lineAmountExcludeTax = values.lineAmountExcludeTax || editGood?.lineAmountExcludeTax;
        if ((lineAmountExcludeTax || lineAmountExcludeTax === 0) && taxAmount !== undefined) {
          const lineAmountIncludeTax = format2(evaluate(`${lineAmountExcludeTax} + ${taxAmount}`));
          form.setFieldsValue({ lineAmountIncludeTax });
          await controller.setEditGood({ lineAmountIncludeTax });

          // 更新含税单价
          const quantity = values.quantity || editGood?.quantity;
          if (quantity || quantity === 0) {
            const priceIncludeTax = format15(evaluate(`${lineAmountIncludeTax} / ${quantity}`), 8);
            if (priceIncludeTax !== undefined && priceIncludeTax !== '') {
              form.setFieldsValue({ priceIncludeTax });
              await controller.setEditGood({ priceIncludeTax });
            }
          }
        }
      }

      await clearCalculatingField(controller);
    });
  },
  1000,
);

/** 小规模纳税人 1% 和 3% 自动赋码免税 */
export function dutyFree(controller: InvoiceController, taxRate: number, form: WrappedFormUtils<any>, record: IGood) {

  const cache = controller.state.goodsListState.endowCode.cache;
  const invoiceType = controller.state.invoiceType;

  // 4月1日至12月31日
  console.log('===> 小规模纳税人免税逻辑');
  console.log('===> invoiceType', invoiceType);
  console.log('===> en', controller.state.en);
  console.log('===> taxRate', taxRate);
  console.log('===> state', controller.state);

  if (moment().valueOf() > moment('2022-12-31 23:59').valueOf()) return taxRate;
  if (controller.state.en !== '08') return taxRate;
  if (invoiceType !== '10' && invoiceType !== '04') return taxRate;

  if (taxRate === 1 || taxRate === 3) {
    cache[record.$index] = { favouredPolicyName: record.favouredPolicyName, favouredPolicyMark: record.favouredPolicyMark, taxFreeType: record.taxFreeType }
    record.favouredPolicyName = '免税';
    record.taxRate = 0;
    record.favouredPolicyMark = 1;
    record.taxFreeType = 1 as any;
    form.setFieldsValue({ taxRate: 0 });
    return 0;
  }
}

/** 含税 => 更新(不含税) */
export const updateUnitPriceExcludingTax = async (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
  return new Promise((resolve) => {
    form.validateFields(async (err, values) => {

      err = err || {};

      /** 税额 */
      let taxAmount;

      /** 金额（不含税） */
      let lineAmountExcludeTax;

      /** 不含税单价 */
      let priceExcludeTax;

      /** 扣除额 */
      const deduction = controller.state.goodsListState.deduction;

      const { editGood } = controller.state.goodsListState

      // 计算税额
      if (!promptErr(err.lineAmountIncludeTax) && !promptErr(err.taxRate)) {
        taxAmount = countTaxAmount(values.lineAmountIncludeTax || editGood?.lineAmountIncludeTax, deduction, values.taxRate);
      }
      form.setFieldsValue({ taxAmount });
      await controller.setEditGood({ taxAmount });

      // 计算 金额(不含税)
      if ((taxAmount || taxAmount === 0) && !promptErr(err.lineAmountIncludeTax)) {
        lineAmountExcludeTax = countAmountExcludeTax(values.lineAmountIncludeTax || editGood?.lineAmountIncludeTax, taxAmount);
      }
      form.setFieldsValue({ lineAmountExcludeTax });
      await controller.setEditGood({ lineAmountExcludeTax });

      // 单价(不含税)
      if (lineAmountExcludeTax && !promptErr(err.quantity)) {
        priceExcludeTax = countPrice(lineAmountExcludeTax, values.quantity || editGood?.quantity, controller.state.calculatingDigits);
      }
      form.setFieldsValue({ priceExcludeTax });
      await controller.setEditGood({ priceExcludeTax });
    });

    resolve(undefined)
  })
};

/** 不含税 => 更新(含税) */
export const updateUnitPriceTax = async (controller: InvoiceController, form: WrappedFormUtils, record: IGood) => {
  return new Promise((resolve) => {
    form.validateFields(async (err, values) => {
      err = err || {};

      if (
        !err.taxRat &&
        (values.taxRate || values.taxRate === 0) &&
        !promptErr(err.lineAmountExcludeTax) &&
        (values.lineAmountExcludeTax || values.lineAmountExcludeTax === 0)
      ) {

        const calculatingDigits = controller.state.calculatingDigits;
        // 金额（含税）= 金额（不含税）* (1+ 税率)
        const lineAmountExcludeTax = format2(values.lineAmountExcludeTax);
        const lineAmountIncludeTax = format2(evaluate(`${lineAmountExcludeTax} * (1+(${values.taxRate}/100))`));
        await controller.setEditGood({ lineAmountIncludeTax });

        // 单价(含税) = 金额（含税） / (數量)
        // 是否有数量
        if (!err.quantity && values.quantity) {
          const priceIncludeTax = format15(evaluate(`${lineAmountIncludeTax} / ${values.quantity}`), 8);
          await controller.setEditGood({ priceIncludeTax });
        }

        // 税额 = 金额(含税)-金额(不含税)
        const taxAmount = evaluate(`${lineAmountIncludeTax} - ${lineAmountExcludeTax}`);
        form.setFieldsValue({ taxAmount });
        await controller.setEditGood({ taxAmount });
      } else {
        form.setFieldsValue({ taxAmount: undefined });
        await controller.setEditGood({ taxAmount: undefined });
      }
      // 单价(含税) = 单价(不含税) * (1+税率)
      // if (
      //   !err.taxRat &&
      //   (values.taxRate || values.taxRate === 0) &&
      //   !promptErr(err.priceExcludeTax) &&
      //   (values.priceExcludeTax || values.priceExcludeTax === 0)
      // ) {
      //   const priceExcludeTax = format15(values.priceExcludeTax);
      //   const priceIncludeTax = format15(evaluate(`${priceExcludeTax} * (1+(${values.taxRate}/100))`));
      //   await controller.setEditGood({ priceIncludeTax });
      // }

      resolve(undefined)
    });
  })
};

/** 保存到编辑货物 */
export const onSaveEditGood = lazyFn(
  (
    controller: InvoiceController,
    form: WrappedFormUtils,
    record: IGood,
    id: string,
  ) => {
    form.validateFields(async (err, values) => {
      err = err || {};
      if (err[id]) return;

      const v = {} as any;
      v[id] = values[id];
      await controller.setEditGood({ ...v });
    });
  },
  1000,
);

/** 单调赋码 */
export const endowCode = async (controller: InvoiceController, goods: IGood) => {
  await controller.wait();
  await controller.saveEditGood();
  await controller.pipeline(async (s) => {
    if (s.goodsListState.form && s.goodsListState.editGood?.$index === goods?.$index) {
      const err: any = s.goodsListState.form.getFieldsError();
      for (let key in err) {
        if (!err[key]) continue;
        message.error(err[key][0]);
        return;
      }
    }

    let g = s.goodsListState.goodsMap.get(goods.$index) as any;
    let i = s.goodsListState.goodsList.indexOf(g);

    switch (goods.lineAttribute) {
      case LineAttributeType.正常:
        s.goodsListState.endowCode.endowcodeGoodIndex = [goods.$index];
        break;

      case LineAttributeType.折扣行:

        s.goodsListState.endowCode.endowcodeGoodIndex = [goods.$index, s.goodsListState.goodsList[i - 1].$index];
        break;

      case LineAttributeType.被折扣行:
        s.goodsListState.endowCode.endowcodeGoodIndex = [goods.$index, s.goodsListState.goodsList[i + 1].$index];
        break;
    }
  })();
}

/** 修改了 项目名称 */
export const onChangeItemName = async (controller: InvoiceController, form: WrappedFormUtils<any>, record: IGood) => {
  controller.run(async s => {
    const value = form.getFieldsValue().itemName;

    if (s.goodsListState.isMyShow) {
      await controller.setEditGood({ itemNameSelf: value });
      record.itemName && await controller.setEditGood({ itemName: record.itemName });
    } else {
      await controller.setEditGood({ itemName: value });
      record.itemNameSelf && await controller.setEditGood({ itemNameSelf: record.itemNameSelf });
    }
  })
}

/** 修改了 商品编码 */
export const onChangeItemCode = async (controller: InvoiceController, form: WrappedFormUtils<any>, record: IGood) => {
  controller.run(async s => {
    const value = form.getFieldsValue().itemCode;

    if (s.goodsListState.isMyShow) {
      await controller.setEditGood({ itemCodeSelf: value });
      record.itemCode && await controller.setEditGood({ itemCode: record.itemCode });
    } else {
      await controller.setEditGood({ itemCode: value });
      record.itemCodeSelf && await controller.setEditGood({ itemCodeSelf: record.itemCodeSelf });
    }
  })
}

/** 修改了含税开关 重新计算 */
export const onChangeSwitchTax = async (controller: InvoiceController, isTaxIncluded: boolean) => {
  if (!controller.state.goodsListState.isRecalculateWhenSwitchTax) {
    controller.pipeline(async s => { s.goodsListState = { ...s.goodsListState, isTaxIncluded } })();
    return
  }
  const calculatingDigits = controller.state.calculatingDigits;

  await controller.saveEditGood();
  await controller.wait();

  await controller.run(async s => {
    if (s.goodsListState.editGood) {
      message.error({
        content: '你正在编辑一个货物',
        key: '你正在编辑一个货物',
      });

      return;
    }

    s.goodsListState.isTaxIncluded = isTaxIncluded;

    try {
      let needRefresh = false;

      if (s.goodsListState?.goodsList && s.goodsListState.goodsList.length) {
        const newGoodsList = s.goodsListState.goodsList.map(good => {
          const {
            quantity: sourceQuantity,
            priceExcludeTax: sourcePriceExcludeTax,
            priceIncludeTax: sourcePriceIncludeTax,
            lineAmountExcludeTax: sourceLineAmountExcludeTax,
            lineAmountIncludeTax: sourceLineAmountIncludeTax,
            taxRate } = good;
          if (isTaxIncluded) {
            if (!sourceQuantity && sourceQuantity !== 0) return good;
            if (!sourcePriceIncludeTax && sourcePriceIncludeTax !== 0) return good;
            if (!taxRate && taxRate !== 0) return good;
            if (sourcePriceExcludeTax && sourceLineAmountExcludeTax && equal(countPrice(sourceLineAmountExcludeTax, sourceQuantity) || 0, sourcePriceExcludeTax)) {
              return good
            } else {
              needRefresh = true;
            }
            const quantity: any = format15(sourceQuantity, calculatingDigits);
            const priceIncludeTax: any = format15(sourcePriceIncludeTax, 8);

            const lineAmountIncludeTax: any = format2(evaluate(`${priceIncludeTax} * ${quantity}`));
            const taxAmount: any = countTaxAmount(lineAmountIncludeTax, controller.state.goodsListState.deduction, taxRate as any);
            const lineAmountExcludeTax: any = countAmountExcludeTax(lineAmountIncludeTax, taxAmount);
            const priceExcludeTax: any = countPrice(lineAmountExcludeTax, quantity, 8);

            return {
              ...good,
              lineAmountExcludeTax,
              lineAmountIncludeTax,
              taxAmount,
              priceExcludeTax
            }

          } else {
            if (!sourceQuantity && sourceQuantity !== 0) return good;
            if (!sourcePriceExcludeTax && sourcePriceExcludeTax !== 0) return good;
            if (!taxRate && taxRate !== 0) return good;
            if (sourcePriceIncludeTax && sourceLineAmountIncludeTax && equal(countPrice(sourceLineAmountIncludeTax, sourceQuantity) || 0, sourcePriceIncludeTax)) {
              return good
            } else {
              needRefresh = true;
            }
            const quantity: any = format15(sourceQuantity, calculatingDigits);
            const priceExcludeTax: any = format15(sourcePriceExcludeTax, 8);

            const lineAmountExcludeTax: any = format2(evaluate(`${priceExcludeTax} * ${quantity}`));
            const lineAmountIncludeTax: any = format2(evaluate(`${lineAmountExcludeTax} * (1+(${taxRate}/100))`));
            const priceIncludeTax: any = format15(evaluate(`${lineAmountIncludeTax} / ${quantity}`), 8);
            const taxAmount: any = evaluate(`${lineAmountIncludeTax} - ${lineAmountExcludeTax}`);

            return {
              ...good,
              lineAmountExcludeTax,
              lineAmountIncludeTax,
              taxAmount,
              priceIncludeTax
            }
          }

        })

        if (needRefresh) {
          s.goodsListState.goodsList = newGoodsList;
        }
      }
    } catch (e) {
      console.error('切换税率重新计算出错', e, s.goodsListState)
    }
  })
}