import { Init, Inject, Provide } from '@midwayjs/core';
import { BaseService, CoolCommException, CoolTransaction } from '@cool-midway/core';
import { PluginService } from '../../plugin/service/info';
import { OrderInfoService } from './info';
import { UserWxService } from '../../user/service/wx';
import BigNumber from 'bignumber.js';
import { OrderInfoEntity } from '../entity/info';
import { InjectEntityModel } from '@midwayjs/typeorm';
import { QueryRunner, Repository } from 'typeorm';
import { Action, OrderQueue } from '../queue/order';
import { BaseSysParamService } from '../../base/service/sys/param';
import { UserInfoEntity } from '../../user/entity/info';
import { RecycleTransactionEntity } from '../../shop/entity/transaction';

/**
 * 支付
 */
@Provide()
export class OrderPayService extends BaseService {
  @InjectEntityModel(OrderInfoEntity)
  orderInfoEntity: Repository<OrderInfoEntity>;

  @InjectEntityModel(UserInfoEntity)
  userInfoEntity: Repository<UserInfoEntity>;

  @InjectEntityModel(RecycleTransactionEntity)
  recycleTransactionEntity: Repository<RecycleTransactionEntity>;

  @Inject()
  pluginService: PluginService;

  @Inject()
  orderInfoService: OrderInfoService;

  @Inject()
  userWxService: UserWxService;

  @Inject()
  orderQueue: OrderQueue;

  @Inject()
  baseSysParamService: BaseSysParamService;

  @Init()
  async init() {
    await super.init();
  }

  /**
   * 支付成功
   * @param orderNum 订单号
   * @param payType 支付方式 0-待支付 1-微信 2-支付宝 3-碳积分
   */
  async paySuccess(orderNum: string, payType: number) {
    const order = await this.orderInfoService.getByOrderNum(orderNum);
    if (order && order.status == 0) {
      await this.orderInfoEntity.update(order.id, {
        payType,
        status: 1,
        payTime: new Date(),
      });
      // 发送自动确认收货队列
      const orderConfirm = await this.baseSysParamService.dataByKey(
        'orderConfirm'
      );
      this.orderQueue.add(
        { orderId: order.id, action: Action.CONFIRM },
        {
          // 自动确认收货时间
          delay: orderConfirm * 60 * 60 * 1000,
        }
      );
    }
    return 'success';
  }

  /**
   * 微信小程序支付
   * @param userId
   * @param orderId
   */
  async wxMiniPay(orderId: number, userId: string) {
    await this.orderInfoEntity.update(orderId, { wxType: 0 });
    return await this.wxJSAPI(orderId, userId, 0);
  }

  /**
   * 微信公众号支付
   * @param userId
   * @param orderId
   */
  async wxMpPay(orderId: number, userId: string) {
    await this.orderInfoEntity.update(orderId, { wxType: 1 });
    return await this.wxJSAPI(orderId, userId, 1);
  }

  /**
   * 获得appid
   * @param type 0-小程序 1-公众号 2-App
   */
  async getAppidByType(type: number) {
    let account;
    const plugin: any = await this.pluginService.getInstance('wx');
    // 小程序
    if (type == 0) {
      account = (await plugin.MiniApp()).getAccount();
    }
    // 公众号
    if (type == 1) {
      account = (await plugin.OfficialAccount()).getAccount();
    }
    // App
    if (type == 2) {
      account = (await plugin.OpenPlatform()).getAccount();
    }
    // 获得appid
    const appid = account.getAppId();
    return appid;
  }

  /**
   * 获得微信支付 SDK 实例
   * @param type 0-小程序 1-公众号 2-App
   * @returns
   */
  async wxPayInstance(appid: string) {
    // 获得插件实例
    const plugin: any = await this.pluginService.getInstance('pay-wx');
    // 获得插件配置
    const config = await plugin.getConfig();
    // 获得微信支付 SDK 实例
    const instance = await plugin.getInstance({
      ...config,
      appid,
    });
    return { config, instance };
  }

  /**
   * 微信APP支付
   * @param orderId
   * @param userId
   * @returns
   */
  async wxAppPay(orderId: number, userId: string) {
    const appid = await this.getAppidByType(2);

    const { config, instance } = await this.wxPayInstance(appid);

    const order = await this.getOrder(orderId, userId);
    const params = {
      description: '商品采购',
      out_trade_no: order?.orderNum,
      notify_url: config.notify_url,
      amount: {
        total: new BigNumber(order.price)
          .minus(order.discountPrice || 0)
          .multipliedBy(100)
          .toNumber(),
      },
    };

    const result = await instance.transactions_app(params);
    return result;
  }

  /**
   * 获得订单
   * @param orderId
   * @param userId
   * @returns
   */
  async getOrder(orderId: number, userId: string) {
    const order: OrderInfoEntity = await this.orderInfoService.info(orderId);
    if (!order || order.status != 0 || order.userId != userId) {
      throw new CoolCommException('订单不存在或不是可以支付的状态');
    }
    return order;
  }

  /**
   * 微信JSAPI
   * @param orderId
   * @param userId
   * @param type 0-小程序 1-公众号 2-App
   * @returns
   */
  async wxJSAPI(orderId: number, userId: string, type = 0) {
    const order = await this.getOrder(orderId, userId);
    const openid = await this.userWxService.getOpenid(userId, type);

    const appid = await this.getAppidByType(type);

    const { config, instance } = await this.wxPayInstance(appid);

    const params = {
      description: '商品采购',
      out_trade_no: order.orderNum,
      notify_url: config.notify_url,
      amount: {
        total: new BigNumber(order.price)
          .minus(order.discountPrice || 0)
          .multipliedBy(100)
          .toNumber(),
      },
      payer: {
        openid,
      },
      scene_info: {
        payer_client_ip: '127.0.0.1',
      },
    };
    const result = await instance.transactions_jsapi(params);
    return result;
  }

  /**
   * 微信退款
   * @param order
   * @param amount
   * @returns
   */
  async wxRefund(order: OrderInfoEntity, amount: number) {
    const appid = await this.getAppidByType(order.wxType);
    const { config, instance } = await this.wxPayInstance(appid);
    const params = {
      out_trade_no: order.orderNum,
      out_refund_no: order.refund.orderNum,
      notify_url: config.notify_url,
      amount: {
        refund: new BigNumber(amount).multipliedBy(100).toNumber(),
        total: new BigNumber(order.price).multipliedBy(100).toNumber(),
        currency: 'CNY',
      },
    };
    const result = await instance.refunds(params);
    if (
      result.status == 200 ||
      result.status == 'SUCCESS' ||
      result.status == 'PROCESSING'
    ) {
      return true;
    }
    throw new CoolCommException(result.message);
  }

  /**
   * 读取碳积分兑换比例，默认 100
   */
  async getCarbonRatio() {
    try {
      const value = await this.baseSysParamService.dataByKey('carbonratio');
      const ratio = Number(value);
      if (ratio > 0) {
        return ratio;
      }
    } catch (e) {}
    return 100;
  }

  /**
   * 碳积分支付：不调用外部渠道
   * 扣减积分 = 订单实付金额 * carbonratio
   */
  @CoolTransaction()
  async carbonPay(orderId: number, userId: string, queryRunner?: QueryRunner) {
    if (!queryRunner) {
      throw new CoolCommException('事务启动失败');
    }

    const manager = queryRunner.manager;
    const order = await manager.findOne(OrderInfoEntity, {
      where: { id: orderId },
    });
    if (!order || order.status != 0 || order.userId != userId) {
      throw new CoolCommException('订单不存在或不是可以支付的状态');
    }

    const user = await manager.findOne(UserInfoEntity, {
      where: { unionid: userId },
    });
    if (!user) {
      throw new CoolCommException('用户不存在');
    }

    const ratio = await this.getCarbonRatio();
    const payAmount = new BigNumber(order.price).minus(order.discountPrice || 0);
    const carbonCost = payAmount.multipliedBy(ratio).toNumber();

    if (Number(user.carbonBalance || 0) < carbonCost) {
      throw new CoolCommException('碳积分不足');
    }

    const dec = await manager
      .createQueryBuilder()
      .update(UserInfoEntity)
      .set({ carbonBalance: () => `carbonBalance - ${carbonCost}` })
      .where('id = :id AND carbonBalance >= :cost', {
        id: userId,
        cost: carbonCost,
      })
      .execute();
    if (!dec.affected) {
      throw new CoolCommException('碳积分不足');
    }

    await manager.update(OrderInfoEntity, order.id, {
      payType: 3,
      status: 1,
      payTime: new Date(),
    });

    await manager.save(RecycleTransactionEntity, {
      userId: user.unionid || String(userId),
      departmentId: user.departmentId,
      type: '支出',
      amount: carbonCost,
      sourceType: '商城',
      remark: `商城订单 ${order.orderNum} 碳积分支付`,
      orderId: order.orderNum,
    });

    const orderConfirm = await this.baseSysParamService.dataByKey('orderConfirm');
    this.orderQueue.add(
      { orderId: order.id, action: Action.CONFIRM },
      {
        delay: orderConfirm * 60 * 60 * 1000,
      }
    );

    return true;
  }
}