import { GenericCrudService } from '@d8d/shared-crud';
import { DataSource } from 'typeorm';
import { DeliveryAddressMt } from '../entities';
import { AreaServiceMt } from '@d8d/geo-areas-mt';
import { AreaLevel } from '@d8d/geo-areas-mt';

export class DeliveryAddressServiceMt extends GenericCrudService<DeliveryAddressMt> {
  private areaService: AreaServiceMt;

  constructor(dataSource: DataSource, areaService: AreaServiceMt) {
    super(dataSource, DeliveryAddressMt);
    this.areaService = areaService;
  }

  /**
   * 获取用户的收货地址列表
   * @param userId 用户ID
   * @param tenantId 租户ID
   * @returns 收货地址列表
   */
  async findByUser(userId: number, tenantId: number): Promise<DeliveryAddressMt[]> {
    return this.repository.find({
      where: { userId, tenantId, state: 1 },
      relations: ['user', 'province', 'city', 'district', 'town'],
      order: { isDefault: 'DESC', createdAt: 'DESC' }
    });
  }

  /**
   * 设置默认地址
   * @param id 地址ID
   * @param userId 用户ID
   * @param tenantId 租户ID
   * @returns 是否设置成功
   */
  async setDefault(id: number, userId: number, tenantId: number): Promise<boolean> {
    await this.repository.manager.transaction(async (transactionalEntityManager) => {
      // 先将该用户的所有地址设为非默认
      await transactionalEntityManager.update(DeliveryAddressMt,
        { userId, tenantId },
        { isDefault: 0 }
      );

      // 将指定地址设为默认
      await transactionalEntityManager.update(DeliveryAddressMt,
        { id, userId, tenantId },
        { isDefault: 1 }
      );
    });

    return true;
  }

  /**
   * 获取用户的默认地址
   * @param userId 用户ID
   * @param tenantId 租户ID
   * @returns 默认地址或null
   */
  async findDefaultByUser(userId: number, tenantId: number): Promise<DeliveryAddressMt | null> {
    return this.repository.findOne({
      where: { userId, tenantId, isDefault: 1, state: 1 },
      relations: ['user', 'province', 'city', 'district', 'town']
    });
  }

  /**
   * 验证地区数据
   * @param provinceId 省份ID
   * @param cityId 城市ID
   * @param districtId 区县ID
   * @param townId 街道ID
   * @param tenantId 租户ID
   * @returns 验证结果
   */
  async validateAreaData(
    provinceId: number,
    cityId: number,
    districtId: number,
    townId: number,
    tenantId: number
  ): Promise<boolean> {
    try {
      // 验证省份
      if (provinceId > 0) {
        const province = await this.areaService.getAreaTreeByLevel(tenantId, AreaLevel.PROVINCE);
        const validProvince = province.some((area: any) => area.id === provinceId);
        if (!validProvince) return false;
      }

      // 验证城市
      if (cityId > 0) {
        const city = await this.areaService.getAreaTreeByLevel(tenantId, AreaLevel.CITY);
        const validCity = city.some((area: any) => area.id === cityId);
        if (!validCity) return false;

        // 验证城市是否属于指定的省份
        if (provinceId > 0) {
          const cityEntity = await this.areaService.getSubTree(tenantId, cityId);
          if (!cityEntity || cityEntity.parentId !== provinceId) {
            return false;
          }
        }
      }

      // 验证区县
      if (districtId > 0) {
        const district = await this.areaService.getAreaTreeByLevel(tenantId, AreaLevel.DISTRICT);
        const validDistrict = district.some((area: any) => area.id === districtId);
        if (!validDistrict) return false;

        // 验证区县是否属于指定的城市
        if (cityId > 0) {
          const districtEntity = await this.areaService.getSubTree(tenantId, districtId);
          if (!districtEntity || districtEntity.parentId !== cityId) {
            return false;
          }
        }
      }

      // 验证街道（如果支持）
      if (townId > 0) {
        // 街道级别的验证可以根据需要扩展
        // 目前假设街道ID是有效的
        return true;
      }

      return true;
    } catch (error) {
      console.error('地区数据验证失败:', error);
      return false;
    }
  }

  /**
   * 创建配送地址（包含地区验证）
   * @param data 创建数据
   * @param tenantId 租户ID
   * @returns 创建的地址
   */
  async createWithValidation(data: Partial<DeliveryAddressMt>, tenantId: number): Promise<DeliveryAddressMt> {
    // 自动设置租户ID
    const addressData = { ...data, tenantId };

    // 验证地区数据
    const isValid = await this.validateAreaData(
      data.receiverProvince || 0,
      data.receiverCity || 0,
      data.receiverDistrict || 0,
      data.receiverTown || 0,
      tenantId
    );

    if (!isValid) {
      throw new Error('地区数据验证失败，请检查省市区信息是否正确');
    }

    return this.create(addressData);
  }

  /**
   * 更新配送地址（包含地区验证）
   * @param id 地址ID
   * @param data 更新数据
   * @param tenantId 租户ID
   * @returns 更新的地址
   */
  async updateWithValidation(id: number, data: Partial<DeliveryAddressMt>, tenantId: number): Promise<DeliveryAddressMt | null> {
    // 验证地区数据
    const isValid = await this.validateAreaData(
      data.receiverProvince || 0,
      data.receiverCity || 0,
      data.receiverDistrict || 0,
      data.receiverTown || 0,
      tenantId
    );

    if (!isValid) {
      throw new Error('地区数据验证失败，请检查省市区信息是否正确');
    }

    // 使用包含租户检查的更新方法
    return this.updateWithTenantCheck(id, data, tenantId);
  }

  /**
   * 更新配送地址（包含租户检查）
   * @param id 地址ID
   * @param data 更新数据
   * @param tenantId 租户ID
   * @returns 更新的地址
   */
  async updateWithTenantCheck(id: number, data: Partial<DeliveryAddressMt>, tenantId: number): Promise<DeliveryAddressMt | null> {
    // 先检查地址是否存在且属于当前租户
    const existingAddress = await this.repository.findOne({
      where: {
        id,
        tenantId
      }
    });

    if (!existingAddress) {
      return null;
    }

    // 更新地址
    Object.assign(existingAddress, data);
    return await this.repository.save(existingAddress);
  }

  /**
   * 删除配送地址（包含租户检查）
   * @param id 地址ID
   * @param tenantId 租户ID
   * @returns 是否删除成功
   */
  async deleteWithTenantCheck(id: number, tenantId: number): Promise<boolean> {
    const result = await this.repository.delete({
      id,
      tenantId
    });
    return result.affected !== 0;
  }
}