import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Service } from '../entities/service.entity';
import { CreateServiceDto, UpdateServiceDto, QueryServiceDto } from './dto/service.dto';

@Injectable()
export class ServiceService {
  constructor(
    @InjectRepository(Service)
    private serviceRepository: Repository<Service>,
  ) {}

  async create(createServiceDto: CreateServiceDto): Promise<Service> {
    // 检查服务类型是否已存在
    const existingService = await this.serviceRepository.findOne({
      where: { type: createServiceDto.type }
    });
    
    if (existingService) {
      throw new ConflictException('该服务类型已存在');
    }

    const service = this.serviceRepository.create({
      ...createServiceDto,
      status: 'active',
    });
    
    return this.serviceRepository.save(service);
  }

  async findAll(query: QueryServiceDto): Promise<any> {
    const { type, status, keyword } = query;
    const queryBuilder = this.serviceRepository.createQueryBuilder('service');

    if (type) {
      queryBuilder.andWhere('service.type = :type', { type });
    }

    if (status) {
      queryBuilder.andWhere('service.status = :status', { status });
    }

    if (keyword) {
      queryBuilder.andWhere(
        '(service.name LIKE :keyword OR service.description LIKE :keyword)',
        { keyword: `%${keyword}%` }
      );
    }

    queryBuilder.orderBy('service.sortOrder', 'ASC');
    queryBuilder.addOrderBy('service.createdAt', 'DESC');

    const services = await queryBuilder.getMany();
    
    return {
      list: services,
      total: services.length
    };
  }

  async findOne(id: number): Promise<Service> {
    const service = await this.serviceRepository.findOne({
      where: { id }
    });

    if (!service) {
      throw new NotFoundException('服务不存在');
    }

    return service;
  }

  async findByType(type: string): Promise<Service> {
    const service = await this.serviceRepository.findOne({
      where: { type }
    });

    if (!service) {
      throw new NotFoundException('服务类型不存在');
    }

    return service;
  }

  async update(id: number, updateServiceDto: UpdateServiceDto): Promise<Service> {
    const service = await this.findOne(id);

    // 如果要更新服务类型，检查新类型是否已被其他服务使用
    if (updateServiceDto.type && updateServiceDto.type !== service.type) {
      const existingService = await this.serviceRepository.findOne({
        where: { type: updateServiceDto.type }
      });
      
      if (existingService) {
        throw new ConflictException('该服务类型已存在');
      }
    }

    await this.serviceRepository.update(id, updateServiceDto);
    return this.findOne(id);
  }

  async remove(id: number): Promise<void> {
    const service = await this.findOne(id);
    await this.serviceRepository.remove(service);
  }

  async getActiveServices(): Promise<any> {
    const services = await this.serviceRepository.find({
      where: { status: 'active' },
      order: { sortOrder: 'ASC', createdAt: 'DESC' }
    });

    return {
      list: services,
      total: services.length
    };
  }

  async updateSortOrder(serviceOrders: { id: number; sortOrder: number }[]): Promise<void> {
    for (const { id, sortOrder } of serviceOrders) {
      await this.serviceRepository.update(id, { sortOrder });
    }
  }

  async toggleStatus(id: number): Promise<Service> {
    const service = await this.findOne(id);
    const newStatus = service.status === 'active' ? 'inactive' : 'active';
    
    await this.serviceRepository.update(id, { status: newStatus });
    return this.findOne(id);
  }
}