import { Provide } from "@midwayjs/core";
import { BaseService, CoolTransaction } from "@cool-midway/core";
import { InjectEntityModel } from "@midwayjs/typeorm";
import { Repository, QueryRunner, EntityManager } from "typeorm";
import { RecycleItemEntity } from "../entity/recycleitem";
import { RecycleOrderEntity } from "../entity/recycleorder";
import { RecycleOrderItemEntity } from '../entity/recycleorderitem';
import { UserInfoEntity } from '../../user/entity/info';
import { RecycleTransactionEntity } from '../entity/transaction';


/**
 * 回收物品订单服务
 */
@Provide()
export class RecycleOrderService extends BaseService {
  @InjectEntityModel(RecycleOrderEntity)
  recycleOrderEntity: Repository<RecycleOrderEntity>;

  @InjectEntityModel(RecycleItemEntity)
  recycleItemEntity: Repository<RecycleItemEntity>;

  @InjectEntityModel(RecycleOrderItemEntity)
  recycleOrderItemEntity: Repository<RecycleOrderItemEntity>;

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

  /**
   * 重写新增，处理订单及详情
   */
  @CoolTransaction()
  async add(param: any, queryRunner?: QueryRunner) {
    const { items, ...orderData } = param;
    // 保存订单
    const order = await queryRunner?.manager.save(RecycleOrderEntity, orderData);
    // 保存详情
    if (items && items.length > 0) {
      const itemEntities = items.map(e => {
        return {
          ...e,
          orderId: order.id,
        };
      });
      await queryRunner?.manager.save(RecycleItemEntity, itemEntities);
    }
    return order;
  }

  /**
   * 重写更新
   */
  @CoolTransaction()
  async update(param: any, queryRunner?: QueryRunner) {
    const { items, id, ...orderData } = param;
    await queryRunner?.manager.update(RecycleOrderEntity, id, orderData);
    if (items) {
      // 先删除旧详情再插入新详情（简单处理）
      await queryRunner?.manager.delete(RecycleItemEntity, { orderId: id });
      const itemEntities = items.map(e => {
        return {
          ...e,
          orderId: id,
        };
      });
      await queryRunner?.manager.save(RecycleItemEntity, itemEntities);
    }
  }

  /**
 * 重写删除逻辑，同步删除订单项
 */
  @CoolTransaction()
  async delete(ids: number[], queryRunner?: QueryRunner) {
    for (const id of ids) {
      const order = await this.recycleOrderEntity.findOneBy({ id });
      if (order) {
        await queryRunner?.manager.delete(RecycleOrderItemEntity, {
          orderNo: order.orderNo,
        });
      }
    }
    await queryRunner?.manager.delete(RecycleOrderEntity, ids);
  }

  @CoolTransaction()
  async saveWithSummary(orderNo: string, items: any[]) {


    // 1️⃣ 先删掉旧明细
    await RecycleOrderItemEntity.delete({ orderNo });

    // 2️⃣ 重新插入
    const newItems = items.map(i => ({
      ...i,
      orderNo
    }));
    console.log(newItems)
    await RecycleOrderItemEntity.save(newItems);

    // 3️⃣ 汇总
    const all = await RecycleOrderItemEntity.find({
      where: { orderNo }
    });

    const totalWeight = all.reduce((s, i) => s + Number(i.weight), 0);
    const totalCarbonPoint = all.reduce((s, i) => s + Number(i.carbonPoint), 0);
    const totalAmount = all.reduce((s, i) => s + Number(i.amount), 0);

    await RecycleOrderEntity.update(
      { orderNo },
      { totalWeight, totalCarbonPoint, totalAmount }
    );

    // 5️⃣ 更新用户碳余额
    const order = await RecycleOrderEntity.findOne({
      where: { orderNo },
      select: ['campusUserId']
    });

    if (order?.campusUserId) {
      await UserInfoEntity.getRepository().increment(
        { unionid: order.campusUserId },
        'carbonBalance',
        totalCarbonPoint
      );
    }

    // 7️⃣ ✅ 用 add() 写流水（重点）
    await RecycleTransactionEntity.save({
      userId: order?.campusUserId,
      departmentId: order?.departmentId,
      type: '收入',
      amount: totalCarbonPoint,
      sourceType: '回收',
      remark: `回收订单 ${orderNo} 获得碳积分`,
      orderId: orderNo
    });

  };

}