import { GenericCrudService } from '@d8d/shared-crud';
import { DataSource, Repository } from 'typeorm';
import { OrderMt } from '../entities/order.mt.entity';
import { OrderGoodsMt } from '../entities/order-goods.mt.entity';
import { OrderRefundMt } from '../entities/order-refund.mt.entity';
import { GoodsMt } from '@d8d/goods-module-mt';
import { DeliveryAddressMt } from '@d8d/delivery-address-module-mt';
import { PaymentMtService } from '@d8d/mini-payment-mt';
import { CreditBalanceService } from '@d8d/credit-balance-module-mt';
import type { CreateOrderRequest } from '../schemas/create-order.schema';

export class OrderMtService extends GenericCrudService<OrderMt> {
  private orderGoodsRepository: Repository<OrderGoodsMt>;
  private goodsRepository: Repository<GoodsMt>;
  private deliveryAddressRepository: Repository<DeliveryAddressMt>;
  private orderRefundRepository: Repository<OrderRefundMt>;
  private paymentMtService: PaymentMtService;
  private creditBalanceService: CreditBalanceService;

  constructor(dataSource: DataSource) {
    super(dataSource, OrderMt, {
      tenantOptions: { enabled: true, tenantIdField: 'tenantId' }
    });
    this.orderGoodsRepository = dataSource.getRepository(OrderGoodsMt);
    this.goodsRepository = dataSource.getRepository(GoodsMt);
    this.deliveryAddressRepository = dataSource.getRepository(DeliveryAddressMt);
    this.orderRefundRepository = dataSource.getRepository(OrderRefundMt);
    this.paymentMtService = new PaymentMtService(dataSource);
    this.creditBalanceService = new CreditBalanceService(dataSource);
  }

  /**
   * 创建订单
   * @param data 创建订单请求数据
   * @param userId 用户ID
   * @param tenantId 租户ID
   * @returns 创建的订单信息
   */
  async createOrder(data: CreateOrderRequest, userId: number, tenantId: number): Promise<{
    success: boolean;
    orderId: number;
    orderNo: string;
    amount: number;
    payAmount: number;
    message: string;
  }> {
    const queryRunner = this.dataSource.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction();

    try {
      const { addressId, productOwn, consumeFrom, products, remark } = data;

      // 验证商品信息并计算总价
      let totalAmount = 0;
      let totalCostAmount = 0;
      const goodsInfo = [];

      for (const item of products) {
        const goods = await this.goodsRepository.findOne({
          where: { id: item.id, tenantId }
        });

        if (!goods) {
          throw new Error(`商品ID ${item.id} 不存在`);
        }

        if (goods.stock < item.num) {
          throw new Error(`商品 ${goods.name} 库存不足`);
        }

        const itemAmount = goods.price * item.num;
        const itemCostAmount = goods.costPrice * item.num;

        totalAmount += itemAmount;
        totalCostAmount += itemCostAmount;

        goodsInfo.push({
          goods,
          quantity: item.num,
          amount: itemAmount,
          costAmount: itemCostAmount
        });
      }

      // 获取收货地址信息
      let deliveryAddress = null;
      if (addressId) {
        deliveryAddress = await this.deliveryAddressRepository.findOne({
          where: { id: addressId, userId, tenantId }
        });

        if (!deliveryAddress) {
          throw new Error('收货地址不存在');
        }
      }

      // 生成订单号
      const orderNo = this.generateOrderNo();

      // 创建订单
      const order = this.repository.create({
        tenantId,
        orderNo,
        userId,
        amount: totalAmount,
        costAmount: totalCostAmount,
        payAmount: totalAmount, // 这里可以根据优惠规则计算实际支付金额
        orderType: 1, // 实物订单
        payType: consumeFrom === '积分兑换' ? 1 : 2, // 根据消费来源设置支付类型
        payState: 0, // 未支付
        state: 0, // 未发货
        addressId: addressId || 0,
        merchantId: goodsInfo[0]?.goods.merchantId || 0,
        supplierId: goodsInfo[0]?.goods.supplierId || 0,
        remark: remark || '',
        createdBy: userId,
        updatedBy: userId,
        // 设置收货地址信息（如果提供）
        ...(deliveryAddress && {
          receiverMobile: deliveryAddress.phone,
          recevierName: deliveryAddress.name,
          recevierProvince: deliveryAddress.receiverProvince,
          recevierCity: deliveryAddress.receiverCity,
          recevierDistrict: deliveryAddress.receiverDistrict,
          recevierTown: deliveryAddress.receiverTown,
          address: deliveryAddress.address
        })
      });

      const savedOrder = await queryRunner.manager.save(order);

      // 创建订单商品明细
      const orderGoodsList = goodsInfo.map(info => ({
        tenantId,
        orderId: savedOrder.id,
        orderNo,
        goodsId: info.goods.id,
        goodsName: info.goods.name,
        imageFileId: info.goods.imageFileId,
        goodsType: info.goods.goodsType,
        supplierId: info.goods.supplierId,
        costPrice: info.goods.costPrice,
        price: info.goods.price,
        num: info.quantity,
        freightAmount: 0,
        state: 0,
        createdBy: userId,
        updatedBy: userId,
        expressName: null,
        expressNo: null
      }));

      await queryRunner.manager.save(OrderGoodsMt, orderGoodsList);

      // 更新商品库存
      for (const item of goodsInfo) {
        await queryRunner.manager.update(GoodsMt, item.goods.id, {
          stock: () => `stock - ${item.quantity}`,
          salesNum: () => `sales_num + ${item.quantity}`
        });
      }

      await queryRunner.commitTransaction();

      return {
        success: true,
        orderId: savedOrder.id,
        orderNo: savedOrder.orderNo,
        amount: savedOrder.amount,
        payAmount: savedOrder.payAmount,
        message: '订单创建成功'
      };

    } catch (error) {
      await queryRunner.rollbackTransaction();
      throw error;
    } finally {
      await queryRunner.release();
    }
  }

  /**
   * 取消订单
   * @param tenantId 租户ID
   * @param orderId 订单ID
   * @param reason 取消原因
   * @param userId 用户ID
   * @returns Promise<void>
   */
  async cancelOrder(tenantId: number, orderId: number, reason: string, userId: number): Promise<void> {
    const queryRunner = this.dataSource.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction();

    try {
      // 查询订单信息
      const order = await this.repository.findOne({
        where: { id: orderId, tenantId, userId }
      });

      if (!order) {
        throw new Error('订单不存在');
      }

      // 验证订单状态（仅允许取消未发货且支付状态为0或2的订单）
      if (order.state !== 0) {
        throw new Error('当前订单状态不允许取消');
      }

      // 验证支付状态
      if (order.payState !== 0 && order.payState !== 2) {
        throw new Error('当前订单状态不允许取消');
      }

      // 对于已支付订单（支付状态=2），需要触发退款流程
      if (order.payState === 2) {
        console.debug(`[租户${tenantId}] 订单 ${orderId} 已支付，开始触发退款流程`);

        try {
          // 调用支付模块的退款功能
          const refundResult = await this.paymentMtService.refund(
            tenantId,
            order.orderNo,
            order.payAmount,
            `订单取消：${reason}`
          );

          console.debug(`[租户${tenantId}] 退款处理成功，退款流水号: ${refundResult.refundId}`);

          // 创建退款记录
          await this.createRefundRecord(tenantId, order, refundResult, userId);

        } catch (error) {
          console.debug(`[租户${tenantId}] 退款处理失败，订单ID: ${orderId}, 错误:`, error);
          // 退款失败不影响订单取消，但记录错误信息
          // 可以在这里添加重试机制或通知管理员
        }
      }

      // 更新订单状态为5（订单关闭），记录取消时间和原因
      await queryRunner.manager.update(OrderMt, { id: orderId, tenantId }, {
        payState: 5, // 订单关闭
        cancelReason: reason,
        cancelTime: new Date(),
        updatedBy: userId,
        updatedAt: new Date()
      });

      // 如果是额度支付订单（payType === 3），需要恢复额度
      if (order.payType === 3) {
        console.debug(`[租户${tenantId}] 额度支付订单 ${orderId} 取消，开始恢复额度`);
        try {
          await this.creditBalanceService.restoreBalanceForCancelOrder(
            tenantId,
            userId,
            order.orderNo,
            order.payAmount,
            userId
          );
          console.debug(`[租户${tenantId}] 额度恢复成功，订单号: ${order.orderNo}`);
        } catch (error) {
          console.debug(`[租户${tenantId}] 额度恢复失败，订单ID: ${orderId}, 错误:`, error);
          // 额度恢复失败不影响订单取消，但记录错误信息
        }
      }

      // 如果订单是未支付状态，需要恢复商品库存
      if (order.payState === 0) {
        // 查询订单商品明细
        const orderGoods = await this.orderGoodsRepository.find({
          where: { orderId, tenantId }
        });

        // 恢复商品库存
        for (const item of orderGoods) {
          await queryRunner.manager.update(GoodsMt, { id: item.goodsId, tenantId }, {
            stock: () => `stock + ${item.num}`,
            salesNum: () => `sales_num - ${item.num}`
          });
        }
      }

      await queryRunner.commitTransaction();
    } catch (error) {
      await queryRunner.rollbackTransaction();
      throw error;
    } finally {
      await queryRunner.release();
    }
  }

  /**
   * 生成订单号
   * 格式：年月日时分秒 + 6位随机数
   */
  private generateOrderNo(): string {
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0');
    const day = String(now.getDate()).padStart(2, '0');
    const hour = String(now.getHours()).padStart(2, '0');
    const minute = String(now.getMinutes()).padStart(2, '0');
    const second = String(now.getSeconds()).padStart(2, '0');
    const random = String(Math.floor(Math.random() * 1000000)).padStart(6, '0');

    return `ORD${year}${month}${day}${hour}${minute}${second}${random}`;
  }

  /**
   * 创建退款记录
   */
  private async createRefundRecord(
    tenantId: number,
    order: OrderMt,
    refundResult: any,
    userId: number
  ): Promise<void> {
    const refundRecord = new OrderRefundMt();
    refundRecord.tenantId = tenantId;
    refundRecord.orderNo = order.orderNo;
    refundRecord.refundOrderNo = refundResult.outRefundNo;
    refundRecord.refundAmount = refundResult.refundAmount;
    refundRecord.state = 2; // 退款成功
    refundRecord.remark = `退款成功，微信退款流水号: ${refundResult.refundId}`;
    refundRecord.createdBy = userId;
    refundRecord.updatedBy = userId;

    await this.orderRefundRepository.save(refundRecord);
    console.debug(`[租户${tenantId}] 退款记录创建成功，退款订单号: ${refundResult.outRefundNo}`);
  }
}