import { DataSource } from 'typeorm';
import { UserMt } from '@d8d/user-module-mt';
import { AreaEntityMt } from '@d8d/geo-areas-mt';
import { DeliveryAddressMt } from '@d8d/delivery-address-module-mt';
import { MerchantMt } from '@d8d/merchant-module-mt';
import { SupplierMt } from '@d8d/supplier-module-mt';
import { OrderMt, OrderRefundMt } from '../../src/entities';
import { JWTUtil } from '@d8d/shared-utils';

/**
 * 订单模块测试数据工厂类
 */
export class OrdersTestDataFactory {
  /**
   * 创建测试用户数据
   */
  static createUserData(overrides: Partial<UserMt> = {}): Partial<UserMt> {
    const timestamp = Math.floor(Math.random() * 100000);
    return {
      username: `test_user_${timestamp}`,
      password: 'test_password',
      nickname: '测试用户',
      registrationSource: 'web',
      ...overrides
    };
  }

  /**
   * 在数据库中创建测试用户
   */
  static async createTestUser(dataSource: DataSource, overrides: Partial<UserMt> = {}): Promise<UserMt> {
    const userData = this.createUserData(overrides);
    const userRepository = dataSource.getRepository(UserMt);
    const user = userRepository.create(userData);
    return await userRepository.save(user);
  }

  /**
   * 为测试用户生成JWT token
   */
  static generateUserToken(user: UserMt): string {
    return JWTUtil.generateToken({
      id: user.id,
      username: user.username,
      roles: [{ name: 'user' }]
    });
  }

  /**
   * 创建测试地区数据
   */
  static createAreaData(overrides: Partial<AreaEntityMt> = {}): Partial<AreaEntityMt> {
    const timestamp = Math.floor(Math.random() * 100000);
    return {
      name: '广东省',
      level: 1,
      code: `44${timestamp.toString().padStart(4, '0')}`,
      state: 1,
      ...overrides
    };
  }

  /**
   * 在数据库中创建测试地区
   */
  static async createTestArea(dataSource: DataSource, overrides: Partial<AreaEntityMt> = {}): Promise<AreaEntityMt> {
    const areaData = this.createAreaData(overrides);
    const areaRepository = dataSource.getRepository(AreaEntityMt);
    const area = areaRepository.create(areaData);
    return await areaRepository.save(area);
  }

  /**
   * 创建完整的地区层级（省、市、区、街道）
   */
  static async createCompleteAreaHierarchy(dataSource: DataSource): Promise<{
    province: AreaEntityMt;
    city: AreaEntityMt;
    district: AreaEntityMt;
    town: AreaEntityMt;
  }> {
    const timestamp = Math.floor(Math.random() * 100000);

    const province = await this.createTestArea(dataSource, {
      name: '广东省',
      level: 1,
      code: `44${timestamp.toString().padStart(4, '0')}`
    });

    const city = await this.createTestArea(dataSource, {
      name: '深圳市',
      level: 2,
      code: `44${(timestamp + 1).toString().padStart(4, '0')}`,
      parentId: province.id
    });

    const district = await this.createTestArea(dataSource, {
      name: '南山区',
      level: 3,
      code: `44${(timestamp + 2).toString().padStart(4, '0')}`,
      parentId: city.id
    });

    const town = await this.createTestArea(dataSource, {
      name: '粤海街道',
      level: 4,
      code: `44${(timestamp + 3).toString().padStart(4, '0')}`,
      parentId: district.id
    });

    return { province, city, district, town };
  }

  /**
   * 创建测试配送地址数据
   */
  static createDeliveryAddressMtData(
    userId: number,
    areaHierarchy: { province: AreaEntityMt; city: AreaEntityMt; district: AreaEntityMt; town: AreaEntityMt },
    overrides: Partial<DeliveryAddressMt> = {}
  ): Partial<DeliveryAddressMt> {
    return {
      userId,
      name: '收货人姓名',
      phone: '13800138000',
      receiverProvince: areaHierarchy.province.id,
      receiverCity: areaHierarchy.city.id,
      receiverDistrict: areaHierarchy.district.id,
      receiverTown: areaHierarchy.town.id,
      address: '测试地址',
      isDefault: 1,
      state: 1,
      createdBy: userId,
      ...overrides
    };
  }

  /**
   * 在数据库中创建测试配送地址
   */
  static async createTestDeliveryAddressMt(
    dataSource: DataSource,
    userId: number,
    areaHierarchy: { province: AreaEntityMt; city: AreaEntityMt; district: AreaEntityMt; town: AreaEntityMt },
    overrides: Partial<DeliveryAddressMt> = {}
  ): Promise<DeliveryAddressMt> {
    const addressData = this.createDeliveryAddressMtData(userId, areaHierarchy, overrides);
    const addressRepository = dataSource.getRepository(DeliveryAddressMt);
    const address = addressRepository.create(addressData);
    return await addressRepository.save(address);
  }

  /**
   * 创建测试商户数据
   */
  static createMerchantMtData(overrides: Partial<MerchantMt> = {}): Partial<MerchantMt> {
    const timestamp = Math.floor(Math.random() * 100000);
    return {
      name: '测试商户',
      username: `merchant_${timestamp}`,
      password: 'test_password',
      state: 1,
      createdBy: 1,
      ...overrides
    };
  }

  /**
   * 在数据库中创建测试商户
   */
  static async createTestMerchantMt(dataSource: DataSource, overrides: Partial<MerchantMt> = {}): Promise<MerchantMt> {
    const merchantData = this.createMerchantMtData(overrides);
    const merchantRepository = dataSource.getRepository(MerchantMt);
    const merchant = merchantRepository.create(merchantData);
    return await merchantRepository.save(merchant);
  }

  /**
   * 创建测试供应商数据
   */
  static createSupplierMtData(overrides: Partial<SupplierMt> = {}): Partial<SupplierMt> {
    const timestamp = Math.floor(Math.random() * 100000);
    return {
      name: '测试供应商',
      username: `supplier_${timestamp}`,
      password: 'test_password',
      state: 1,
      createdBy: 1,
      ...overrides
    };
  }

  /**
   * 在数据库中创建测试供应商
   */
  static async createTestSupplierMt(dataSource: DataSource, overrides: Partial<SupplierMt> = {}): Promise<SupplierMt> {
    const supplierData = this.createSupplierMtData(overrides);
    const supplierRepository = dataSource.getRepository(SupplierMt);
    const supplier = supplierRepository.create(supplierData);
    return await supplierRepository.save(supplier);
  }

  /**
   * 创建测试订单数据
   */
  static createOrderMtData(
    userId: number,
    deliveryAddressId: number,
    merchantId: number,
    supplierId: number,
    areaHierarchy: { province: AreaEntityMt; city: AreaEntityMt; district: AreaEntityMt; town: AreaEntityMt },
    overrides: Partial<OrderMt> = {}
  ): Partial<OrderMt> {
    const timestamp = Math.floor(Math.random() * 100000);
    return {
      orderNo: `ORDER_${timestamp}`,
      userId,
      amount: 100.00,
      costAmount: 80.00,
      payAmount: 100.00,
      orderType: 1,
      payType: 1,
      payState: 2,
      state: 0,
      deliveryAddressId,
      addressId: deliveryAddressId,
      merchantId,
      supplierId,
      recevierProvince: areaHierarchy.province.id,
      recevierCity: areaHierarchy.city.id,
      recevierDistrict: areaHierarchy.district.id,
      recevierTown: areaHierarchy.town.id,
      createdBy: userId,
      ...overrides
    };
  }

  /**
   * 在数据库中创建测试订单
   */
  static async createTestOrderMt(
    dataSource: DataSource,
    userId: number,
    deliveryAddressId: number,
    merchantId: number,
    supplierId: number,
    areaHierarchy: { province: AreaEntityMt; city: AreaEntityMt; district: AreaEntityMt; town: AreaEntityMt },
    overrides: Partial<OrderMt> = {}
  ): Promise<OrderMt> {
    const orderData = this.createOrderMtData(userId, deliveryAddressId, merchantId, supplierId, areaHierarchy, overrides);
    const orderRepository = dataSource.getRepository(OrderMt);
    const order = orderRepository.create(orderData);
    return await orderRepository.save(order);
  }

  /**
   * 创建完整的测试订单环境（包含所有依赖实体）
   */
  static async createCompleteOrderMtEnvironment(dataSource: DataSource, userId?: number): Promise<{
    user: UserMt;
    areaHierarchy: { province: AreaEntityMt; city: AreaEntityMt; district: AreaEntityMt; town: AreaEntityMt };
    deliveryAddress: DeliveryAddressMt;
    merchant: MerchantMt;
    supplier: SupplierMt;
    order: OrderMt;
  }> {
    // 创建用户
    const user = await this.createTestUser(dataSource, userId ? { id: userId } : {});

    // 创建地区层级
    const areaHierarchy = await this.createCompleteAreaHierarchy(dataSource);

    // 创建商户和供应商
    const merchant = await this.createTestMerchantMt(dataSource, { createdBy: user.id });
    const supplier = await this.createTestSupplierMt(dataSource, { createdBy: user.id });

    // 创建配送地址
    const deliveryAddress = await this.createTestDeliveryAddressMt(dataSource, user.id, areaHierarchy);

    // 创建订单
    const order = await this.createTestOrderMt(dataSource, user.id, deliveryAddress.id, merchant.id, supplier.id, areaHierarchy);

    return { user, areaHierarchy, deliveryAddress, merchant, supplier, order };
  }

  /**
   * 创建测试退款数据
   */
  static createRefundData(orderNo: string, overrides: Partial<OrderRefundMt> = {}): Partial<OrderRefundMt> {
    const timestamp = Math.floor(Math.random() * 100000);
    return {
      orderNo,
      refundOrderMtNo: `REFUND_${timestamp}`,
      refundAmount: 50.00,
      state: 0,
      createdBy: 1,
      ...overrides
    };
  }

  /**
   * 在数据库中创建测试退款
   */
  static async createTestRefund(
    dataSource: DataSource,
    orderNo: string,
    overrides: Partial<OrderRefundMt> = {}
  ): Promise<OrderRefundMt> {
    const refundData = this.createRefundData(orderNo, overrides);
    const refundRepository = dataSource.getRepository(OrderRefundMt);
    const refund = refundRepository.create(refundData);
    return await refundRepository.save(refund);
  }
}