import { PgPool } from "@arborknot/db";
import { loggerManager } from "@logger";
import { PluralDomainObject } from "domain-objects/domain-objects.interface";
import { format } from "util";
import { WebhookEventHandler } from "./providers/webhook-event-handler";
import { Request } from "express";
//import { Cache } from "@cache";
const { v4: uuidv4 } = require("uuid");
import { ICache } from "@arborknot/cache";
import { IWebHook } from "./interface-webhook";

export class Webhooks implements IWebHook {
    private readonly webhookEventHandler: WebhookEventHandler;

    constructor(private readonly db: PgPool, private readonly cache: ICache) {
        this.webhookEventHandler = new WebhookEventHandler(this.cache);
    }

    async insert(headers: Request["headers"], query: Request["query"], body: string, traceId: string) {
        let id = uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

        try {
            let eventsWithMetadata = await this.webhookEventHandler.toEvents(headers, query, body, traceId);
            //const id = uuidv4();
            console.log(eventsWithMetadata);
            await Promise.allSettled(
                eventsWithMetadata.map(async ({ event, eventMetadata }) => {
                    const {
                        customerId,
                        phone,
                        email,
                        transactionId,
                        priority,
                        eventId,
                        eventProvider,
                        eventType,
                        eventName,
                        eventBody,
                        eventErrorCode,
                        eventOptType,
                        userAgent,
                    } = eventMetadata;

                    const queryResponse = await this.db.query<{ id: string }>(
                        `
                        INSERT INTO webhook (id,headers, query, body, debt_id, event_id , event_provider, event_name, 
											event_type, event_body, event_error_code, event_opt_type , priority)
                        SELECT $16 AS id,$5 AS headers , $6 AS query, $7 AS body,
                            d.id  AS debt_id, $8 AS event_id, 
                            $9 AS event_provider, $10 AS event_event, 
                            $11 AS event_type, $12 AS event_body, 
                            $13 AS event_error_code, $14 AS event_opt_type,
                            $15 AS priority
                        FROM debt AS d
                        WHERE 
                            ($1::TEXT IS NOT NULL AND d.customer_id = $1::UUID)
                        OR (($2::TEXT IS NOT NULL OR $3::TEXT IS NOT NULL) AND EXISTS (
                            SELECT 1
                            FROM customer_contact_details AS ccd
                            WHERE (ccd.contact in ($2::TEXT,$3::TEXT))
                                AND ccd.customer_id = d.customer_id
                        ))
                        OR ($4::TEXT IS NOT NULL AND EXISTS (
                            SELECT 1
                            FROM transaction as t
                            WHERE t.id = $4::UUID
                                AND t.debt_id = d.id
                            )
                        )
                        RETURNING *; 
            `,
                        [
                            customerId,
                            phone,
                            email,
                            transactionId,
                            headers,
                            query,
                            event,
                            eventId,
                            eventProvider,
                            eventName,
                            eventType,
                            eventBody,
                            eventErrorCode,
                            eventOptType,
                            priority,
                            id,
                        ],
                    );
                    const webhook = queryResponse.rows[0];
                    if (webhook) {
                        loggerManager.info(
                            `Successfully added the webhook: ${webhook.id}, and user-agent: ${userAgent}`,
                        );
                        return;
                    }
                    loggerManager.error(`No rows were added for webhook of and handler: ${userAgent}`);
                }),
            ).then((promises) => {
                promises.forEach(
                    (promise) => promise.status == "rejected" && loggerManager.error(format(promise.reason)),
                );
            });
        } catch (e) {
            loggerManager.error(format(e));
        }
    }
}