import { Global, Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

import { CargoType } from './entities/cargo-type.entity';
import { ContainerType } from './entities/container-type.entity';
import { PriorityRule } from './entities/priority-rule.entity';
import { Surcharge } from './entities/surcharge.entity';
import { SurchargeType } from './entities/surcharge-type.entity';
import { ServiceType } from './entities/service-type.entity';
import { WeightLimitRule } from './entities/weight-limit-rule.entity';

import { CARGO_TYPES_REPOSITORY } from './interfaces/cargo-types.repository.interface';
import { CONTAINER_TYPES_REPOSITORY } from './interfaces/container-types.repository.interface';
import { PRIORITY_RULES_REPOSITORY } from './interfaces/priority-rules.repository.interface';
import { SURCHARGES_REPOSITORY } from './interfaces/surcharges.repository.interface';
import { SURCHARGE_TYPES_REPOSITORY } from './interfaces/surcharge-types.repository.interface';
import { SERVICE_TYPES_REPOSITORY } from './interfaces/service-types.repository.interface';
import { WEIGHT_LIMIT_RULES_REPOSITORY } from './interfaces/weight-limit-rules.repository.interface';

import { CargoTypesRepository } from './repositories/cargo-types.repository';
import { ContainerTypesRepository } from './repositories/container-types.repository';
import { PriorityRulesRepository } from './repositories/priority-rules.repository';
import { SurchargesRepository } from './repositories/surcharges.repository';
import { SurchargeTypesRepository } from './repositories/surcharge-types.repository';
import { ServiceTypesRepository } from './repositories/service-types.repository';
import { WeightLimitRulesRepository } from './repositories/weight-limit-rules.repository';

import { CargoTypesService } from './services/cargo-types.service';
import { ContainerTypesService } from './services/container-types.service';
import { PriorityRulesService } from './services/priority-rules.service';
import { SurchargesService } from './services/surcharges.service';
import { SurchargeTypesService } from './services/surcharge-types.service';
import { ServiceTypesService } from './services/service-types.service';
import { WeightLimitRulesService } from './services/weight-limit-rules.service';

import { CargoTypesController } from './controllers/cargo-types.controller';
import { ContainerTypesController } from './controllers/container-types.controller';
import { PriorityRulesController } from './controllers/priority-rules.controller';
import { SurchargesController } from './controllers/surcharges.controller';
import { SurchargeTypesController } from './controllers/surcharge-types.controller';
import { ServiceTypesController } from './controllers/service-types.controller';
import { WeightLimitRulesController } from './controllers/weight-limit-rules.controller';

import { RuleEngineService } from './rule-engine.service';

@Global()
@Module({
  imports: [
    TypeOrmModule.forFeature([
      CargoType,
      ContainerType,
      PriorityRule,
      Surcharge,
      SurchargeType,
      ServiceType,
      WeightLimitRule,
    ]),
  ],
  controllers: [
    CargoTypesController,
    ContainerTypesController,
    PriorityRulesController,
    SurchargesController,
    SurchargeTypesController,
    ServiceTypesController,
    WeightLimitRulesController,
  ],
  providers: [
    // Repositories
    CargoTypesRepository,
    { provide: CARGO_TYPES_REPOSITORY, useExisting: CargoTypesRepository },
    ContainerTypesRepository,
    { provide: CONTAINER_TYPES_REPOSITORY, useExisting: ContainerTypesRepository },
    PriorityRulesRepository,
    { provide: PRIORITY_RULES_REPOSITORY, useExisting: PriorityRulesRepository },
    SurchargesRepository,
    { provide: SURCHARGES_REPOSITORY, useExisting: SurchargesRepository },
    SurchargeTypesRepository,
    { provide: SURCHARGE_TYPES_REPOSITORY, useExisting: SurchargeTypesRepository },
    ServiceTypesRepository,
    { provide: SERVICE_TYPES_REPOSITORY, useExisting: ServiceTypesRepository },
    WeightLimitRulesRepository,
    { provide: WEIGHT_LIMIT_RULES_REPOSITORY, useExisting: WeightLimitRulesRepository },
    // CRUD services
    CargoTypesService,
    ContainerTypesService,
    PriorityRulesService,
    SurchargesService,
    SurchargeTypesService,
    ServiceTypesService,
    WeightLimitRulesService,
    // Evaluation engine
    RuleEngineService,
  ],
  exports: [
    RuleEngineService,
    CargoTypesService,
    ServiceTypesService,
    ContainerTypesService,
    SurchargeTypesService,
    SurchargesService,
    WeightLimitRulesService,
    PriorityRulesService,
  ],
})
export class RuleEngineModule {}