import { Injectable } from '@nestjs/common';
import { Create{{pascalCase name}}Manager } from './managers/create-{{dashCase name}}.manager';
import { {{pascalCase name}}DataService } from '../../data/services/{{dashCase name}}-data.service';
import { {{pascalCase name}}Entity } from '../entities/{{dashCase name}}.entity';
import { Delete{{pascalCase name}}Manager } from './managers/delete-{{dashCase name}}.manager';
import { Update{{pascalCase name}}Manager } from './managers/update-{{dashCase name}}.manager';
import { BaseDataTransactionOrchestrator } from 'src/core/modules/domain/usecase/orchestrators/base-data-transaction.orchestrator';
import { Active{{pascalCase name}}Manager } from './managers/active-{{dashCase name}}.manager';
import { Inactive{{pascalCase name}}Manager } from './managers/inactive-{{dashCase name}}.manager';
import { Confirm{{pascalCase name}}Manager } from './managers/confirm-{{dashCase name}}.manager';
import { STATUS } from 'src/core/strings/constants/base.constants';
import { BatchResult } from 'src/core/response/domain/ok-response.interface';
import { BatchConfirm{{pascalCase name}}Manager } from './managers/batch-confirm-{{dashCase name}}.manager';
import { BatchInactive{{pascalCase name}}Manager } from './managers/batch-inactive-{{dashCase name}}.manager';
import { BatchActive{{pascalCase name}}Manager } from './managers/batch-active-{{dashCase name}}.manager';
import { BatchDelete{{pascalCase name}}Manager } from './managers/batch-delete-{{dashCase name}}.manager';
import { TABLE_NAME } from 'src/core/strings/constants/table.constants';

@Injectable()
export class {{pascalCase name}}DataOrchestrator extends Base{{pascalCase orchestrator}}Orchestrator<{{pascalCase name}}Entity> {
    constructor(
        private createManager: Create{{pascalCase name}}Manager,
        private updateManager: Update{{pascalCase name}}Manager,
        private deleteManager: Delete{{pascalCase name}}Manager,
        private activeManager: Active{{pascalCase name}}Manager,
        private confirmManager: Confirm{{pascalCase name}}Manager,
        private inactiveManager: Inactive{{pascalCase name}}Manager,
        private batchDeleteManager: BatchDelete{{pascalCase name}}Manager,
        private batchActiveManager: BatchActive{{pascalCase name}}Manager,
        private batchConfirmManager: BatchConfirm{{pascalCase name}}Manager,
        private batchInactiveManager: BatchInactive{{pascalCase name}}Manager,
        private serviceData: {{pascalCase name}}DataService,
    ) {
        super();
    }

    async create(data): Promise<{{pascalCase name}}Entity> {
        this.createManager.setData(data);
        this.createManager.setService(this.serviceData, TABLE_NAME.{{constantCase name}});
        await this.createManager.execute();
        return this.createManager.getResult();
    }

    async update(dataId, data): Promise<{{pascalCase name}}Entity> {
        this.updateManager.setData(dataId, data);
        this.updateManager.setService(this.serviceData, TABLE_NAME.{{constantCase name}});
        await this.updateManager.execute();
        return this.updateManager.getResult();
    }

    async delete(dataId): Promise<string> {
        this.deleteManager.setData(dataId);
        this.deleteManager.setService(this.serviceData, TABLE_NAME.{{constantCase name}});
        await this.deleteManager.execute();
        return this.deleteManager.getResult();
    }

    async batchDelete(dataIds: string[]): Promise<BatchResult> {
        this.batchDeleteManager.setData(dataIds);
        this.batchDeleteManager.setService(
            this.serviceData,
            TABLE_NAME.{{constantCase name}},
        );
        await this.batchDeleteManager.execute();
        return this.batchDeleteManager.getResult();
    }

    async active(dataId): Promise<string> {
        this.activeManager.setData(dataId, STATUS.ACTIVE);
        this.activeManager.setService(this.serviceData, TABLE_NAME.{{constantCase name}});
        await this.activeManager.execute();
        return this.activeManager.getResult();
    }

    async batchActive(dataIds: string[]): Promise<BatchResult> {
        this.batchActiveManager.setData(dataIds, STATUS.ACTIVE);
        this.batchActiveManager.setService(
            this.serviceData,
            TABLE_NAME.{{constantCase name}},
        );
        await this.batchActiveManager.execute();
        return this.batchActiveManager.getResult();
    }

    async confirm(dataId): Promise<string> {
        this.confirmManager.setData(dataId, STATUS.ACTIVE);
        this.confirmManager.setService(this.serviceData, TABLE_NAME.{{constantCase name}});
        await this.confirmManager.execute();
        return this.confirmManager.getResult();
    }

    async batchConfirm(dataIds: string[]): Promise<BatchResult> {
        this.batchConfirmManager.setData(dataIds, STATUS.ACTIVE);
        this.batchConfirmManager.setService(
            this.serviceData,
            TABLE_NAME.{{constantCase name}},
        );
        await this.batchConfirmManager.execute();
        return this.batchConfirmManager.getResult();
    }

    async inactive(dataId): Promise<string> {
        this.inactiveManager.setData(dataId, STATUS.INACTIVE);
        this.inactiveManager.setService(
            this.serviceData,
            TABLE_NAME.{{constantCase name}},
        );
        await this.inactiveManager.execute();
        return this.inactiveManager.getResult();
    }

    async batchInactive(dataIds: string[]): Promise<BatchResult> {
        this.batchInactiveManager.setData(dataIds, STATUS.INACTIVE);
        this.batchInactiveManager.setService(
            this.serviceData,
            TABLE_NAME.{{constantCase name}},
        );
        await this.batchInactiveManager.execute();
        return this.batchInactiveManager.getResult();
    }
}