import { DynamicModule, Logger, Module, OnModuleInit } from '@nestjs/common';
import { EventEmitterService } from './event-emitter.service';
import { RedmineEventsGateway } from './events/redmine-events.gateway';
import { ServeStaticModule } from '@nestjs/serve-static';
import { join } from 'path';
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';

@Module({})
export class EventEmitterModule implements OnModuleInit {
  static register(params?: ModuleParams): DynamicModule {
    return {
      module: EventEmitterModule,
      imports: [
        ServeStaticModule.forRoot({
          rootPath: join(__dirname, '..', 'client'),
        }),
        ConfigModule.forRoot({ load: [() => params?.config || MainConfig()] }),
      ],
      providers: [
        EventEmitterService,
        RedmineEventsGateway,
        RedmineDataLoader,
        RedmineIssuesCacheWriterService,
        CouchDb,
        Users,
        Issues,
        RedmineUserCacheWriterService,
        UsersService,
        IssuesService,
      ],
      exports: [
        EventEmitterService,
        RedmineEventsGateway,
        RedmineDataLoader,
        RedmineIssuesCacheWriterService,
        CouchDb,
        Users,
        Issues,
        RedmineUserCacheWriterService,
        UsersService,
        IssuesService,
      ],
      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: any) => {
      this.logger.debug(`Changed issues = ${JSON.stringify(issues)}`);

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

        try {
          this.logger.debug(
            `Save issue #${issue.id} - ${JSON.stringify(issue)}`,
          );

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

          this.logger.debug(
            `Save issue #${issue.id} response = ${JSON.stringify(response)}`,
          );
        } catch (ex) {
          this.logger.error(`Saving issue error - ${ex}`, null, {
            issue: issue,
          });
        }
      }
    });
  }
}