import { CacheConfig } from './defs';
import _ from 'lodash';
import { isMyKepLive } from './utils';
import {
    Api,
    EmddExtendedProcess,
    EmddProcess,
    Id,
} from '@digigov-oss/emdd-api-client';

type ApiRequestFunction<T> = (id: Id) => Promise<T>;

export class EmddProcessTransformer {
    private readonly client: Api;
    private readonly cacheConfig?: CacheConfig;
    cacheHits = 0;

    constructor(client: Api, cacheConfig?: CacheConfig) {
        this.client = client;
        this.cacheConfig = cacheConfig;
    }

    transformExtendedProcess = (
        process: EmddExtendedProcess,
    ): Promise<EmddExtendedProcess> => {
        const payload = process as any;

        if (isMyKepLive(payload)) {
            _.set(payload, 'metadata.process.is_served_via_mykeplive', true);
        }

        // map cost_min, cost_max
        for (const path of [
            'metadata.process.cost_min',
            'metadata.process.cost_max',
        ]) {
            const value = _.get(payload, path);
            if (value) {
                _.set(payload, path, parseFloat(_.get(payload, path)));
            }
        }

        return Promise.resolve(payload);
    };

    transformProcess = async (
        process: EmddProcess,
    ): Promise<EmddExtendedProcess> => {
        const payload = process as any;

        // map cost_min, cost_max
        for (const path of [
            'metadata.process.cost_min',
            'metadata.process.cost_max',
        ]) {
            const value = _.get(payload, path);
            if (value) {
                _.set(payload, path, parseFloat(_.get(payload, path)));
            }
        }

        const cl = this.client;
        const promises: Promise<void>[] = [];
        // map org_owner
        const orgOwner = _.get(payload, 'metadata.process.org_owner');
        if (orgOwner) {
            promises.push(
                this.mapToEmbedded(
                    orgOwner,
                    `organization-${orgOwner}`,
                    cl.getOrganization,
                ).then((v) => {
                    _.set(payload, 'metadata.process.org_owner', v);
                }),
            );
        } else {
            _.set(payload, 'metadata.process.org_owner', undefined);
        }

        // map provision_org
        promises.push(
            Promise.all(
                _.get(payload, 'metadata.process.provision_org', []).map(
                    async (x: string | number) => {
                        return this.mapToEmbedded(
                            x,
                            `organization-${x}`,
                            cl.getOrganization,
                        );
                    },
                ),
            ).then((l) => {
                _.set(payload, 'metadata.process.provision_org', l);
            }),
        );

        // // map provision_org_group
        promises.push(
            Promise.all(
                _.get(payload, 'metadata.process.provision_org_group', []).map(
                    async (x: string | number) => {
                        return this.mapToEmbedded(
                            x,
                            `provision-org-group-${x}`,
                            cl.getProvisionOrgGroup,
                        );
                    },
                ),
            ).then((l) => {
                _.set(payload, 'metadata.process.provision_org_group', l);
            }),
        );

        // // map provision_org_group_remote
        promises.push(
            Promise.all(
                _.get(
                    payload,
                    'metadata.process.provision_org_group_remote',
                    [],
                ).map(async (x: string | number) => {
                    return this.mapToEmbedded(
                        x,
                        `provision-org-group-${x}`,
                        cl.getProvisionOrgGroup,
                    );
                }),
            ).then((l) => {
                _.set(
                    payload,
                    'metadata.process.provision_org_group_remote',
                    l,
                );
            }),
        );

        // map provision_org_owner_directory
        promises.push(
            Promise.all(
                _.get(
                    payload,
                    'metadata.process.provision_org_owner_directory',
                    [],
                ).map(async (x: string | number) => {
                    return this.mapToEmbedded(x, `unit-${x}`, cl.getUnit);
                }),
            ).then((l) => {
                _.set(
                    payload,
                    'metadata.process.provision_org_owner_directory',
                    l,
                );
            }),
        );

        // map nace_codes
        promises.push(
            Promise.all(
                _.get(payload, 'metadata.process.nace_codes', []).map(
                    async (x: string | number) => {
                        return this.mapToEmbedded(
                            x,
                            `nace-code-${x}`,
                            cl.getNaceCode,
                        );
                    },
                ),
            ).then((l) => {
                _.set(payload, 'metadata.process.nace_codes', l);
            }),
        );

        // // map sdg_codes
        promises.push(
            Promise.all(
                _.get(payload, 'metadata.process.sdg_codes', []).map(
                    async (x: string | number) => {
                        return this.mapToEmbedded(
                            x,
                            `sdg-code-${x}`,
                            cl.getSdgCode,
                        );
                    },
                ),
            ).then((l) => {
                _.set(payload, 'metadata.process.sdg_codes', l);
            }),
        );

        // // map output_registries
        promises.push(
            Promise.all(
                _.get(payload, 'metadata.process.output_registries', []).map(
                    async (x: string | number) => {
                        return this.mapToEmbedded(
                            x,
                            `registry-${x}`,
                            cl.getRegistry,
                        );
                    },
                ),
            ).then((l) => {
                _.set(payload, 'metadata.process.output_registries', l);
            }),
        );

        // map evidence types
        promises.push(
            Promise.all(
                _.get(payload, 'metadata.process_evidences', []).map(
                    async (ev: any) => {
                        const ev_type = ev?.evidence_type;
                        if (ev_type !== undefined) {
                            ev.evidence_type = await this.mapToEmbedded(
                                ev_type,
                                `evidence-${ev_type}`,
                                cl.getEvidence,
                            );
                        }
                        return ev;
                    },
                ),
            ).then((l) => {
                _.set(payload, 'metadata.process_evidences', l);
            }),
        );

        return Promise.all(promises).then(() => {
            if (isMyKepLive(payload)) {
                _.set(
                    payload,
                    'metadata.process.is_served_via_mykeplive',
                    true,
                );
            }
            return payload as unknown as EmddExtendedProcess;
        });
    };

    private async mapToEmbedded<T>(
        id: Id,
        key: string,
        func: ApiRequestFunction<T>,
    ) {
        const execFunc = async () => {
            return func(id).catch(() => {
                return {
                    id: id,
                    title: {
                        el: `${id}`,
                        en: `${id}`,
                    },
                };
            });
        };
        const cacheConfig = this.cacheConfig;
        if (cacheConfig) {
            const cacheKey = `${
                this.cacheConfig?.cacheKeyPrefix ?? 'EMDD-MITOS'
            }-${key}`;
            return cacheConfig.cache.get(cacheKey).then((v) => {
                if (v) {
                    this.cacheHits++;
                    return v as T;
                } else {
                    return execFunc().then(async (r) => {
                        await cacheConfig.cache.set(
                            cacheKey,
                            r,
                            cacheConfig.ttl,
                        );
                        return r;
                    });
                }
            });
        }
        return execFunc();
    }
}

export default EmddProcessTransformer;