import { BadRequestException, Inject, Injectable, NotFoundException } from '@nestjs/common';
import { CreatePriorityConfigDto } from '../dto/create-priority-config.dto';
import { UpdatePriorityConfigDto } from '../dto/update-priority-config.dto';
import { PriorityConfig } from '../entities/priority-config.entity';
import {
  IPriorityConfigsRepository,
  PRIORITY_CONFIGS_REPOSITORY,
} from '../interfaces/priority-configs.repository.interface';
import { DisplayOrderService } from './display-order.service';

@Injectable()
export class PriorityConfigsService {
  constructor(
    @Inject(PRIORITY_CONFIGS_REPOSITORY)
    private readonly repository: IPriorityConfigsRepository,
    private readonly displayOrder: DisplayOrderService,
  ) {}

  async findAll(filter: {
    type?: 'WAGON' | 'CURRENCY';
    isActive?: boolean;
    page?: number;
    pageSize?: number;
  }): Promise<{ data: PriorityConfig[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
    const page = filter.page ?? 1;
    const pageSize = filter.pageSize ?? 20;
    const where: Record<string, unknown> = {};
    if (filter.type !== undefined) where.type = filter.type;
    if (filter.isActive !== undefined) where.isActive = filter.isActive;

    const [data, total] = await this.repository.findAndCount({
      where,
      order: { displayOrder: 'ASC' },
      skip: (page - 1) * pageSize,
      take: pageSize,
    });
    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
  }

  async findById(id: string): Promise<PriorityConfig> {
    const entity = await this.repository.findById(id);
    if (!entity) throw new NotFoundException(`Priority config ${id} not found`);
    return entity;
  }

  async create(dto: CreatePriorityConfigDto): Promise<PriorityConfig> {
    this.validateCurrencyField(dto.type, dto.currency);

    const displayOrder = await this.displayOrder.resolveCreateOrder(PriorityConfig, 'displayOrder', {});

    return this.repository.create({
      type: dto.type,
      label: dto.label,
      currency: dto.currency ?? null,
      minWagonCount: dto.minWagonCount,
      maxWagonCount: dto.maxWagonCount,
      scorePoints: dto.scorePoints ?? 0,
      isActive: dto.isActive ?? false,
      displayOrder,
    });
  }

  async update(id: string, dto: UpdatePriorityConfigDto): Promise<PriorityConfig> {
    const existing = await this.findById(id);

    const type = dto.type ?? existing.type;
    const currency = dto.currency !== undefined ? dto.currency : existing.currency;
    this.validateCurrencyField(type, currency);

    const { ...patch } = dto;
    const updated = await this.repository.update(id, patch);
    if (!updated) throw new NotFoundException(`Priority config ${id} not found`);
    return updated;
  }

  async remove(id: string): Promise<void> {
    await this.findById(id);
    await this.repository.softDelete(id);
  }

  async reorder(ids: string[]): Promise<void> {
    await this.displayOrder.reorderByIds(PriorityConfig, 'displayOrder', ids);
  }

  async moveOrder(id: string, direction: 'up' | 'down'): Promise<void> {
    await this.findById(id);
    await this.displayOrder.moveOne(PriorityConfig, 'displayOrder', id, direction);
  }

  private validateCurrencyField(type: 'WAGON' | 'CURRENCY', currency: string | undefined | null): void {
    if (type === 'CURRENCY' && !currency) {
      throw new BadRequestException('currency field is required when type is CURRENCY');
    }
    if (type === 'WAGON' && currency) {
      throw new BadRequestException('currency field must be null when type is WAGON');
    }
  }
}
