import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { CreateTABLE_UPPER_NAMEDto } from "OUT_DIR/dto/TABLE_PLURAL_LOWER_NAME/create-TABLE_LOWER_NAME.dto";
import { UpdateTABLE_UPPER_NAMEDto } from "OUT_DIR/dto/TABLE_PLURAL_LOWER_NAME/update-TABLE_LOWER_NAME.dto";
import { TABLE_UPPER_NAME } from "OUT_DIR/entities";
import { createHandler, deleteHandler, getAllHandler, getByIdHandler, updateHandler, upsertHandler } from "OUT_DIR/helpers";
import { deletedRes, errorRes, newInstanceRes, updatedRes } from "OUT_DIR/responses";
import { CustomResponseType, DeleteQueryProps, FullTokenPayload } from "OUT_DIR/types";
import { TABLE_LOWER_NAMEFileFields } from "src/dto/TABLE_PLURAL_LOWER_NAME/TABLE_LOWER_NAME-files";
import { TablesNames } from "src/enums/tables.enum";
import { getCleanDto, linkUploadedFilesToRecord } from "src/helpers/cleanDtoData";
import { FilesService } from "src/schemas/files/files.service";
import { DeleteResult, FindManyOptions, Repository, UpdateResult } from "typeorm";

@Injectable()
export class TABLE_PLURAL_UPPER_NAMEService {
    constructor(
        // ----- external services -----
        private readonly fileService: FilesService,
        // ----- base services -----
        @InjectRepository(TABLE_UPPER_NAME)
        private readonly TABLE_LOWER_NAMERepository: Repository<TABLE_UPPER_NAME>
    ) {}

    // --- Basic CRUD APIs ---

    async getTABLE_PLURAL_UPPER_NAME(
        query: FindManyOptions
    ): Promise<CustomResponseType<TABLE_UPPER_NAME[]>> {
        return await getAllHandler<TABLE_UPPER_NAME>({
            query,
            repository: this.TABLE_LOWER_NAMERepository,
            table: TablesNames.TABLE_UPPER_SNAKE_CASE_NAME,
            fileService: this.fileService,
        });
    }

    async getTABLE_UPPER_NAMEById(id: string): Promise<CustomResponseType<TABLE_UPPER_NAME>> {
        return await getByIdHandler<TABLE_UPPER_NAME>({
            id,
            repository: this.TABLE_LOWER_NAMERepository,
            table: TablesNames.TABLE_UPPER_SNAKE_CASE_NAME,
            fileService: this.fileService,
        });
    }

    async createTABLE_UPPER_NAME(
        createTABLE_UPPER_NAMEDto: CreateTABLE_UPPER_NAMEDto,
    ): Promise<CustomResponseType<TABLE_UPPER_NAME>> {
        try {
            const cleanDto = getCleanDto(createTABLE_UPPER_NAMEDto, TABLE_LOWER_NAMEFileFields);            

            const response = await createHandler<TABLE_UPPER_NAME>({
                dto: cleanDto,
                repository: this.TABLE_LOWER_NAMERepository,
            });

            await linkUploadedFilesToRecord(response, TABLE_LOWER_NAMEFileFields, TablesNames.TABLE_UPPER_SNAKE_CASE_NAME, createTABLE_UPPER_NAMEDto, this.fileService)

            return newInstanceRes<TABLE_UPPER_NAME>(
                "TABLE_UPPER_NAME has been created successfully",
                response
            );
        } catch (error) {
            return errorRes(error.message);
        }
    }

    async createBulkTABLE_UPPER_NAME(
        createTABLE_UPPER_NAMEDtos: CreateTABLE_UPPER_NAMEDto[],
    ): Promise<CustomResponseType<TABLE_UPPER_NAME[]>> {
        try {
            const responses = await Promise.all(
                createTABLE_UPPER_NAMEDtos.map(async(dto) => await this.createTABLE_UPPER_NAME(dto))
            );

            return newInstanceRes<TABLE_UPPER_NAME[]>(
                `Bulk TABLE_UPPER_NAME creation successful`,
                responses.map(r => r.payload as TABLE_UPPER_NAME),
            );
        } catch (error) {
            return errorRes(error.message);
        }
    }

    async updateTABLE_UPPER_NAME(
        id: string,
        updateTABLE_UPPER_NAMEDto: UpdateTABLE_UPPER_NAMEDto
    ): Promise<CustomResponseType<UpdateResult & { newRecord: TABLE_UPPER_NAME }>> {
        try {
            const cleanDto = getCleanDto(updateTABLE_UPPER_NAMEDto, TABLE_LOWER_NAMEFileFields);

            const response = await updateHandler<TABLE_UPPER_NAME>({
                id,
                dto: cleanDto,
                table: TablesNames.TABLE_UPPER_SNAKE_CASE_NAME,
                repository: this.TABLE_LOWER_NAMERepository,
            });

            await linkUploadedFilesToRecord({id}, TABLE_LOWER_NAMEFileFields, TablesNames.TABLE_UPPER_SNAKE_CASE_NAME, updateTABLE_UPPER_NAMEDto, this.fileService)


            return updatedRes<UpdateResult & { newRecord: TABLE_UPPER_NAME }>(
                "TABLE_UPPER_NAME has been updated successfully",
                response
            );
        } catch (error) {
            return errorRes(error.message);
        }
    }

    async updateBulkTABLE_UPPER_NAME(
        updates: { id: string; data: UpdateTABLE_UPPER_NAMEDto }[]
    ): Promise<CustomResponseType<(UpdateResult & { newRecord: TABLE_UPPER_NAME })[]>> {
        try {
            const responses = await Promise.all(
                updates.map(async({ id, data }) => await this.updateTABLE_UPPER_NAME(id, data))
            );

            return updatedRes<(UpdateResult & { newRecord: TABLE_UPPER_NAME })[]>(
                "TABLE_UPPER_NAME items updated successfully",
                responses.map(r => r.payload as UpdateResult & { newRecord: TABLE_UPPER_NAME })
            );
        } catch (error) {
            return errorRes(error.message);
        }
    }

    async upsertTABLE_UPPER_NAME(
        lookupPropName: string,
        updateTABLE_UPPER_NAMEDto: UpdateTABLE_UPPER_NAMEDto
    ): Promise<CustomResponseType<TABLE_UPPER_NAME>> {
        try {
            const response = await upsertHandler<TABLE_UPPER_NAME>({
                lookupPropName,
                dto: updateTABLE_UPPER_NAMEDto,
                // table: "TABLE_UPPER_NAME",
                repository: this.TABLE_LOWER_NAMERepository,
            });

            return updatedRes<TABLE_UPPER_NAME>(
                "TABLE_UPPER_NAME has been upserted successfully",
                response
            );
        } catch (error) {
            return errorRes(error.message);
        }
    }

    async deleteTABLE_UPPER_NAME(
        query: DeleteQueryProps,
        userTokenData: Partial<FullTokenPayload>
    ): Promise<CustomResponseType<DeleteResult>> {
        const { id, wipe } = query;

        return await deleteHandler<TABLE_UPPER_NAME>({
            id,
            wipe,
            repository: this.TABLE_LOWER_NAMERepository,
            table: "TABLE_UPPER_NAME",
            userTokenData,
        });
    }

    async deleteBulkTABLE_UPPER_NAME(
        query: { ids: string; wipe?: boolean },
        userTokenData: Partial<FullTokenPayload>
    ): Promise<CustomResponseType<DeleteResult[]>> {
        const { ids, wipe } = query;

        try {
            const results = await Promise.all(
                JSON.parse(ids).map(async(id: string) =>
                    await this.deleteTABLE_UPPER_NAME({ id, wipe }, userTokenData)
                )
            );

            return deletedRes("TABLE_UPPER_NAME items deleted successfully", results.map(r => r.payload as DeleteResult));
        } catch (error) {
            return errorRes(error.message);
        }
    }
}