import { DataSource } from 'typeorm';
import { UserEntityMt } from '@d8d/core-module-mt/user-module-mt/entities';
import { OrderMt } from '@d8d/orders-module-mt';
import { MerchantMt } from '@d8d/merchant-module-mt';
import { SupplierMt } from '@d8d/supplier-module-mt';
import { DeliveryAddressMt } from '@d8d/delivery-address-module-mt';
import { AreaEntityMt, AreaLevel } from '@d8d/geo-areas-mt';
import { JWTUtil } from '@d8d/shared-utils';

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

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

  /**
   * 创建测试商户
   */
  static async createTestMerchant(dataSource: DataSource, tenantId: number, overrides: Partial<MerchantMt> = {}): Promise<MerchantMt> {
    const merchantRepository = dataSource.getRepository(MerchantMt);
    const randomNum = Math.floor(Math.random() * 1000000); // 0-999999的随机数
    const merchantData: Partial<MerchantMt> = {
      tenantId,
      name: `测试商户_${randomNum}`,
      username: `m${randomNum}`, // 确保不超过20个字符
      password: 'test_password',
      phone: '13800138000',
      realname: '测试联系人',
      state: 1, // 1=启用
      ...overrides
    };
    const merchant = merchantRepository.create(merchantData);
    return await merchantRepository.save(merchant);
  }

  /**
   * 创建测试供应商
   */
  static async createTestSupplier(dataSource: DataSource, tenantId: number, overrides: Partial<SupplierMt> = {}): Promise<SupplierMt> {
    const supplierRepository = dataSource.getRepository(SupplierMt);
    const randomNum = Math.floor(Math.random() * 1000000); // 0-999999的随机数
    const supplierData: Partial<SupplierMt> = {
      tenantId,
      name: `测试供应商_${randomNum}`,
      username: `s${randomNum}`, // 确保不超过50个字符
      password: 'test_password',
      phone: '13800138000',
      realname: '测试联系人',
      state: 1, // 1=启用
      ...overrides
    };
    const supplier = supplierRepository.create(supplierData);
    return await supplierRepository.save(supplier);
  }

  /**
   * 创建测试地区实体
   */
  static async createTestArea(dataSource: DataSource, tenantId: number, level: AreaLevel = AreaLevel.PROVINCE, overrides: Partial<AreaEntityMt> = {}): Promise<AreaEntityMt> {
    const areaRepository = dataSource.getRepository(AreaEntityMt);
    const randomNum = Math.floor(Math.random() * 1000000);
    const areaData: Partial<AreaEntityMt> = {
      tenantId,
      name: `测试地区_${randomNum}`,
      code: `CODE${randomNum}`,
      level,
      parentId: null,
      isDisabled: 0, // 启用
      isDeleted: 0, // 未删除
      ...overrides
    };
    const area = areaRepository.create(areaData);
    return await areaRepository.save(area);
  }

  /**
   * 创建测试配送地址
   */
  static async createTestDeliveryAddress(dataSource: DataSource, tenantId: number, userId: number, overrides: Partial<DeliveryAddressMt> = {}): Promise<DeliveryAddressMt> {
    // 创建测试地区实体（省级）
    const provinceArea = await this.createTestArea(dataSource, tenantId, AreaLevel.PROVINCE);

    const addressRepository = dataSource.getRepository(DeliveryAddressMt);
    const addressData: Partial<DeliveryAddressMt> = {
      tenantId,
      userId,
      name: '测试收货人',
      phone: '13800138000',
      address: '测试详细地址',
      receiverProvince: provinceArea.id, // 使用实际地区ID
      receiverCity: provinceArea.id, // 简化：使用同一个ID
      receiverDistrict: provinceArea.id, // 简化：使用同一个ID
      receiverTown: provinceArea.id, // 简化：使用同一个ID
      isDefault: 0, // 0=不常用
      state: 1, // 1=正常
      ...overrides
    };
    const address = addressRepository.create(addressData);
    return await addressRepository.save(address);
  }

  /**
   * 创建测试订单（用于统计数据）
   */
  static async createTestOrder(
    dataSource: DataSource,
    tenantId: number,
    userId: number,
    options: {
      merchantId?: number;
      supplierId?: number;
      addressId?: number;
    } = {},
    overrides: Partial<OrderMt> = {}
  ): Promise<OrderMt> {
    const orderRepository = dataSource.getRepository(OrderMt);
    const timestamp = Date.now();
    const orderNo = `ORD${timestamp}${Math.floor(Math.random() * 1000)}`;

    // 创建必需的外键实体（如果未提供）
    let merchantId = options.merchantId;
    let supplierId = options.supplierId;
    let addressId = options.addressId;

    if (!merchantId) {
      const merchant = await this.createTestMerchant(dataSource, tenantId);
      merchantId = merchant.id;
    }

    if (!supplierId) {
      const supplier = await this.createTestSupplier(dataSource, tenantId);
      supplierId = supplier.id;
    }

    if (!addressId) {
      const address = await this.createTestDeliveryAddress(dataSource, tenantId, userId);
      addressId = address.id;
    }

    // 默认创建一个已支付的订单，用于统计
    const defaultOrder: Partial<OrderMt> = {
      tenantId,
      orderNo,
      userId,
      amount: 100.00,
      costAmount: 80.00,
      payAmount: 100.00,
      orderType: 1,
      payType: 1, // 1=积分支付（假设为微信支付）
      payState: 2, // 2=支付成功
      state: 1,
      addressId,
      merchantId,
      supplierId,
      createdBy: userId,
      updatedBy: userId,
      createdAt: new Date(),
      updatedAt: new Date()
    };

    const order = orderRepository.create({
      ...defaultOrder,
      ...overrides
    });

    return await orderRepository.save(order);
  }

  /**
   * 批量创建测试订单
   */
  static async createTestOrders(
    dataSource: DataSource,
    tenantId: number,
    count: number,
    options: {
      userId?: number;
      payType?: 1 | 3; // 1=积分支付（微信支付），3=额度支付（信用支付）
      dateOffsetDays?: number; // 日期偏移（负数表示过去）
    } = {}
  ): Promise<OrderMt[]> {
    const orders: OrderMt[] = [];

    // 如果没有提供userId，创建一个测试用户
    let userId = options.userId;
    if (!userId) {
      const user = await this.createTestUser(dataSource, tenantId);
      userId = user.id;
    }

    for (let i = 0; i < count; i++) {
      // 交替创建积分支付和额度支付的订单
      const payType = options.payType || (i % 2 === 0 ? 1 : 3); // 1=积分支付，3=额度支付
      const amount = 50.00 + (i * 25.00); // 不同金额

      // 处理日期偏移
      let createdAt = new Date();
      if (options.dateOffsetDays) {
        createdAt.setDate(createdAt.getDate() + options.dateOffsetDays);
      }

      const order = await this.createTestOrder(dataSource, tenantId, userId, {}, {
        orderNo: `ORD${Date.now()}${i}`,
        payType,
        amount,
        payAmount: amount,
        createdAt,
        updatedAt: createdAt
      });

      orders.push(order);
    }

    return orders;
  }

  /**
   * 创建今日测试订单
   */
  static async createTodayTestOrders(
    dataSource: DataSource,
    tenantId: number,
    count: number
  ): Promise<OrderMt[]> {
    return await this.createTestOrders(dataSource, tenantId, count, {
      dateOffsetDays: 0 // 今天
    });
  }

  /**
   * 创建历史测试订单（过去几天）
   */
  static async createHistoricalTestOrders(
    dataSource: DataSource,
    tenantId: number,
    count: number,
    daysAgo: number = 7
  ): Promise<OrderMt[]> {
    return await this.createTestOrders(dataSource, tenantId, count, {
      dateOffsetDays: -daysAgo
    });
  }

  /**
   * 为测试用户生成JWT token
   */
  static generateUserToken(user: UserEntityMt): string {
    return JWTUtil.generateToken({
      id: user.id,
      username: user.username,
      tenantId: user.tenantId
    });
  }

  /**
   * 为管理员生成JWT token
   */
  static generateAdminToken(tenantId: number): string {
    return JWTUtil.generateToken({
      id: 1,
      username: 'admin',
      tenantId
    });
  }

  /**
   * 生成指定租户和用户ID的测试token
   */
  static generateTokenForUser(tenantId: number, userId: number, username: string = 'test_user'): string {
    return JWTUtil.generateToken({
      id: userId,
      username,
      tenantId
    });
  }
}