import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { ECSClient } from '@aws-sdk/client-ecs';
import { S3Client } from '@aws-sdk/client-s3';
import { SQSClient } from '@aws-sdk/client-sqs';
import { Logger } from '@squiz/optimization-logger';
import { ContainerModule, interfaces } from 'inversify';
import {
  InjectTokens,
  JobContextService,
  JobDetailsRepository,
  JobExecutionRepository,
  JobExecutionTaskService,
  JobManifestService,
  JobStartQueueService,
  JobUploadsRepository,
} from '../../domains/job';
import { CreateJobRunnerModuleProps, CreateJobRunnerModuleResult } from './buildJobRunnerModule.types';

export const buildJobRunnerModule = (props: CreateJobRunnerModuleProps): CreateJobRunnerModuleResult => {
  let dynamoDbClient: DynamoDBClient;
  let s3Client: S3Client;
  let ecsClient: ECSClient;
  let sqsClient: SQSClient;

  if (props.local) {
    dynamoDbClient = new DynamoDBClient({
      credentials: { accessKeyId: 'key', secretAccessKey: 'key' },
      endpoint: 'http://localhost:8000',
    });
    s3Client = new S3Client({
      credentials: { accessKeyId: 'key', secretAccessKey: 'key' },
      endpoint: 'http://localhost:4566', // This is the localstack EDGE_PORT
      forcePathStyle: true,
    });
    ecsClient = new ECSClient({});
    sqsClient = new SQSClient({
      credentials: { accessKeyId: 'key', secretAccessKey: 'key' },
      endpoint: 'http://localhost:4566',
    });
  } else {
    dynamoDbClient = new DynamoDBClient({ region: props.awsRegion });
    s3Client = new S3Client({ region: props.awsRegion });
    ecsClient = new ECSClient({ region: props.awsRegion });
    sqsClient = new SQSClient({ region: props.awsRegion });
  }

  return ({ tenant, logger }: { tenant?: string; logger: Logger }) => {
    return new ContainerModule((bind: interfaces.Bind) => {
      bind(DynamoDBClient).toConstantValue(dynamoDbClient);
      bind(S3Client).toConstantValue(s3Client);
      bind(ECSClient).toConstantValue(ecsClient);
      bind(SQSClient).toConstantValue(sqsClient);

      bind(InjectTokens.Logger).toConstantValue(logger);
      bind(InjectTokens.Tenant).toConstantValue(tenant);
      bind(InjectTokens.DynamoTableName).toConstantValue(props.dynamoTableName);
      bind(InjectTokens.JobUploadsBucket).toConstantValue(props.jobUploadsBucket);
      bind(InjectTokens.JobDetailsBucket).toConstantValue(props.jobDetailsBucket);

      if (props.jobStartQueueUrl) {
        bind(InjectTokens.JobStartQueueUrl).toConstantValue(props.jobStartQueueUrl);
        bind<JobStartQueueService>(JobStartQueueService).toDynamicValue(
          (context: interfaces.Context) =>
            new JobStartQueueService(sqsClient, context.container.get(InjectTokens.JobStartQueueUrl)),
        );
      }

      bind<JobExecutionTaskService>(JobExecutionTaskService).toDynamicValue(
        (context: interfaces.Context) =>
          new JobExecutionTaskService(
            ecsClient,
            context.container.get(JobManifestService),
            context.container.get(JobContextService),
            context.container.get(JobExecutionRepository),
            context.container.get(JobDetailsRepository),
            context.container.get(JobUploadsRepository),
          ),
      );
    });
  };
};