import { GenericCrudService } from '@d8d/shared-crud';
import { DataSource, Repository, Like, Not } from 'typeorm';
import { Company } from '../entities/company.entity';

export class CompanyService extends GenericCrudService<Company> {
  private searchFields = ['companyName', 'contactPerson', 'contactPhone'];

  constructor(dataSource: DataSource) {
    super(dataSource, Company);
  }

  /**
   * 创建公司 - 覆盖父类方法，添加公司名称在同一平台下唯一性检查
   */
  async create(data: Partial<Company>, userId?: string | number): Promise<Company> {
    // 检查公司名称是否在同一平台下已存在
    if (data.companyName && data.platformId) {
      const existingCompany = await this.repository.findOne({
        where: { companyName: data.companyName, platformId: data.platformId }
      });
      if (existingCompany) {
        throw new Error('公司名称在该平台下已存在');
      }
    }

    // 设置默认值
    const companyData = {
      contactEmail: '',
      address: '',
      ...data,
      status: 1,
      createTime: new Date(),
      updateTime: new Date()
    };

    return super.create(companyData, userId);
  }

  /**
   * 更新公司 - 覆盖父类方法，添加存在性和名称重复检查
   */
  async update(id: number, data: Partial<Company>, userId?: string | number): Promise<Company | null> {
    // 检查公司是否存在
    const company = await this.repository.findOne({ where: { id } });
    if (!company) {
      throw new Error('公司不存在');
    }

    // 检查公司名称是否与同一平台下的其他公司重复
    const platformId = data.platformId ?? company.platformId;
    const companyName = data.companyName ?? company.companyName;

    if (companyName !== company.companyName || platformId !== company.platformId) {
      const existingCompany = await this.repository.findOne({
        where: {
          companyName,
          platformId,
          id: Not(id)
        }
      });
      if (existingCompany) {
        throw new Error('公司名称在该平台下已存在');
      }
    }

    // 设置更新时间
    const updateData = {
      ...data,
      updateTime: new Date()
    };

    return super.update(id, updateData, userId);
  }

  /**
   * 删除公司 - 覆盖父类方法，改为软删除（设置status为0）
   */
  async delete(id: number, userId?: string | number): Promise<boolean> {
    // 改为软删除：设置status为0
    const result = await this.repository.update({ id }, { status: 0 });
    return result.affected === 1;
  }

  /**
   * 获取所有公司（分页） - 自定义方法，返回源服务的格式，加载平台关联
   */
  async findAll(skip?: number, take?: number): Promise<{ data: Company[], total: number }> {
    const [data, total] = await this.repository.findAndCount({
      relations: ['platform'],
      where: { status: 1 }, // 只返回正常状态的公司
      skip: skip ?? 0,
      take: take ?? 10,
      order: { id: 'DESC' }
    });
    return { data, total };
  }

  /**
   * 按名称搜索公司 - 自定义方法，加载平台关联
   */
  async searchByName(name: string, skip?: number, take?: number): Promise<{ data: Company[], total: number }> {
    const [data, total] = await this.repository.findAndCount({
      relations: ['platform'],
      where: {
        companyName: Like(`%${name}%`),
        status: 1 // 只返回正常状态的公司
      },
      skip: skip ?? 0,
      take: take ?? 10,
      order: { id: 'DESC' }
    });
    return { data, total };
  }

  /**
   * 按平台ID查询公司 - 自定义方法
   */
  async findByPlatform(platformId: number): Promise<Company[]> {
    return this.repository.find({
      where: { platformId }
    });
  }

  /**
   * 获取单个公司 - 自定义方法，加载平台关联
   */
  async findOne(id: number): Promise<Company | null> {
    return this.repository.findOne({
      where: { id },
      relations: ['platform']
    });
  }

  /**
   * 创建公司（兼容源服务API）- 返回布尔值
   */
  async createCompany(data: Partial<Company>): Promise<boolean> {
    try {
      await this.create(data);
      return true;
    } catch (error) {
      console.error('创建公司失败:', error);
      // 重新抛出错误，让路由层处理
      throw error;
    }
  }

  /**
   * 删除公司（兼容源服务API）- 返回布尔值
   */
  async deleteCompany(id: number): Promise<boolean> {
    try {
      return await this.delete(id);
    } catch (error) {
      console.error('删除公司失败:', error);
      return false;
    }
  }

  /**
   * 更新公司（兼容源服务API）- 返回布尔值
   */
  async updateCompany(data: Partial<Company> & { id: number }): Promise<boolean> {
    try {
      const { id, ...updateData } = data;
      await this.update(id, updateData);
      return true;
    } catch (error) {
      console.error('更新公司失败:', error);
      // 重新抛出错误，让路由层处理
      throw error;
    }
  }
}