import { DynamicModule, Logger, Module, OnModuleInit } from '@nestjs/common';
import { EventEmitterService } from './event-emitter.service';
import { RedmineEventsGateway } from './events/redmine-events.gateway';
import MainConfig from './configs/main-config';
import { ConfigModule } from '@nestjs/config';
import { RedmineDataLoader } from './redmine-data-loader/redmine-data-loader';
import { MainController } from './main/main.controller';
import { ModuleParams } from './models/module-params';
import { RedmineIssuesCacheWriterService } from './issue-cache-writer/redmine-issues-cache-writer.service';
import { CouchDb } from './couchdb-datasources/couchdb';
import { Users } from './couchdb-datasources/users';
import { Issues } from './couchdb-datasources/issues';
import { RedmineUserCacheWriterService } from './user-cache-writer/user-cache-writer.service';
import { UsersController } from './users/users.controller';
import { RedmineTypes } from './models/redmine-types';
import { UsersService } from './users/users.service';
import { IssuesService } from './issues/issues.service';
import { IssuesController } from './issues/issues.controller';
import { TimestampEnhancer } from './issue-enhancers/timestamps-enhancer';
import { EnhancerService } from './issue-enhancers/enhancer.service';

@Module({})
export class EventEmitterModule implements OnModuleInit {
  static register(params?: ModuleParams): DynamicModule {
    return {
      module: EventEmitterModule,
      imports: [
        ConfigModule.forRoot({ load: [() => params?.config || MainConfig()] }),
      ],
      providers: [
        EventEmitterService,
        RedmineEventsGateway,
        RedmineDataLoader,
        RedmineIssuesCacheWriterService,
        CouchDb,
        Users,
        Issues,
        RedmineUserCacheWriterService,
        UsersService,
        IssuesService,
        TimestampEnhancer,
        EnhancerService,
      ],
      exports: [
        EventEmitterService,
        RedmineEventsGateway,
        RedmineDataLoader,
        RedmineIssuesCacheWriterService,
        CouchDb,
        Users,
        Issues,
        RedmineUserCacheWriterService,
        UsersService,
        IssuesService,
        TimestampEnhancer,
        EnhancerService,
      ],
      controllers: [MainController, UsersController, IssuesController],
    };
  }

  private logger = new Logger(EventEmitterModule.name);

  constructor(
    private redmineEventsGateway: RedmineEventsGateway,
    private redmineIssuesCacheWriterService: RedmineIssuesCacheWriterService,
  ) {}

  onModuleInit() {
    const queue = this.redmineEventsGateway.getIssuesChangesQueue();
    const subj = queue.queue;
    subj.subscribe(async (issues: RedmineTypes.Issue[]) => {
      this.logger.debug(
        `Changed issues - ` +
          issues.map((i) => `#${i.id} (${i.subject})`).join(', '),
      );

      for (let i = 0; i < issues.length; i++) {
        const issue: RedmineTypes.Issue = issues[i];

        try {
          this.logger.debug(`Save issue #${issue.id} (${issue.subject})`);

          const response = await this.redmineIssuesCacheWriterService.saveIssue(
            issue,
          );

          this.logger.debug(
            // eslint-disable-next-line prettier/prettier
            `Save ${(response.prev) ? 'exists' : 'new'} issue #${issue.id} - count of changes = ${response.journalsDiff.length}`,
          );
        } catch (ex) {
          this.logger.error(`Saving issue error - ${ex}`, null, {
            issue: issue,
          });
        }
      }
    });
  }
}