import { HttpMethod } from "../../../core/models/core.model";
import { HttpService } from "../../../core/services/http.service";
import { ChatInfoForm, Entity, IActivityData, IChatItems, ICurrentMatchData, IEntityHighlight, IIntent, IIntentCategory, IIntentRequestCount, IKLRequest, IMatchData, IMatchedInfo, IRequestCountInSession, IRequestData, ITagsData } from "../models";

const CurrentMatchedUrl = "aisera/requests/currentMatched";
const ActivitiesUrl = "/aisera/requests/activities";
const ChatItemsUrl = "aisera/conversations/chat";
const RequestUrl = "aisera/requests";
const IntentsUrl = "/aisera/intents";
const EntityList = "aisera/entityLists";
const EntityListMappings = "aisera/entityListMappings";
const UpdateAutoCategorizationCategoryUrl = "/api/v1/request/update-autocategorisation";
const FetchRequestCountPerIntentUrl = "/api/v1/request/request-count-per-intent";
const FetchChannelToken = "aisera/channels";
const FetchCurrentMatchForPhrase = "aisera/webchat/receive";
const EntitiesHighlightsUrl = "aisera/requests/entitiesHighlight";
const CreateNewTagUrl = "/api/v1/request/create-new-tag";


const RequestDetailsService = {
    async fetchRequestInfo(requestId: number): Promise<IRequestData> {
        const requestData = {
            "fields": [
                "resolution_status",
                "resolution_detail",
                "intents.id",
                "intents.name",
                "content",
                "sor_ticket_uri",
                "bot_id",
                "requestFulfillments.producer",
                "conversation.error_message",
                "entities.id",
                "entities.entity_name",
                "_historicalEvents",
                "_reviewStatus",
                "requestAutocategorization.autotagging_category",
                "id",
                "created_at",
                "status",
                "_isEscalated",
                "escalation_type",
                "sor_ticket_id",
                "assigned_to_id",
                "assignee.name",
                "assignee.user_email",
                "reporter_id",
                "user.name",
                "user.user_email",
                "clientDevice.location_city",
                "clientDevice.location_country",
                "conversation.feedback_answer",
                "session.language_detected.code",
                "channel_id",
                "channel.name",
                "channel.channel_type_id",
                "external_channel_name",
                "session_id",
                "conversation.duration",
                "sentimentPrediction.first_prediction",
                "sessionFeedback.score",
                "updated_at",
                "agent_handoff_id",
                "agent_handoff_at",
                "title"
            ],
            "includeDeletedIntents": true,
            "removeDuplicateIntents": true,
            "entityId": requestId
        }
        const response = await HttpService.request({
            url: RequestUrl,
            requestData
        });
        return response;
    },

    async fetchIntents(intentIds: number[]): Promise<string[] | undefined> {
        const requestData = {
            "fields": [
                "category.category"
            ],
            "criteria": [
                {
                    "field": "id",
                    "operator": "IN",
                    "operand": intentIds
                }
            ]
        };
        const result = await HttpService.request({
            url: IntentsUrl,
            requestData,
        });
        if (result?.length) {
            return result.map((a: IIntentCategory) => a.category.category || "None")
        }
    },

    async fetchCurrentMatch(requestId: number): Promise<ICurrentMatchData> {
        return await HttpService.request({
            url: CurrentMatchedUrl,
            requestData: {
                requestId
            },
        });
    },

    async fetchActivities(requestId: number): Promise<IActivityData[]> {
        const requestData = {
            fields: ["activity_type", "entity_id", "content", "created_at", "channel_type_id", "channel.name",
                "user_id", "user.name", "user.user_email", "channel_event_type"],
            criteria: [{ field: "ai_ticket_id", operand: requestId }],
            sortCriteria: [{ field: "created_at" }],
            normalizeAgentAssist: true
        };
        const activities = await HttpService.request({
            url: ActivitiesUrl,
            requestData,
        }) as IActivityData[];
        for (const activity of activities) {
            if(activity.entity_id) {
                activity.chats = await this.fetchChat(activity.entity_id);
            } else if(activity?.chatItems?.length) {
                activity.chats = activity?.chatItems;
            }
            if(activity.channel_type_id === 6) {
                const requestData = await this.fetchRequestInfo(requestId);

                const intents = requestData?.intents?.map((a: IIntent) => a.id);
                if (intents?.length) {
                    const intentsData = await this.fetchIntents(intents);
                    requestData._intentsCategories = intentsData as string[];
                } else {
                    requestData._intentsCategories = "None";
                }

                if(requestData.session_id) {
                    const requestCountInSession = await this.fetchRequestCountInSession(requestData.session_id);
                    requestData.totalRequestsInSession = requestCountInSession.totalCount;
                } else {
                    requestData.totalRequestsInSession = 1;
                }

                if (requestData) {
                    if (activity.chats && activity.chats.length > 0 && requestData?.content) {
                        activity.chats[0].question = `<b class="email-header">Subject:</b><br /> ${requestData?.content?.emailSubject || "N/A"}<br /><br /><b class="email-header">Email Body:</b><br /> ${requestData?.content?.emailBody || "N/A"}`;
                        activity.chats[0].isHtml = true;
                        activity.chats[0].isEmailContent = true;
                        activity.chats[0].attachements = requestData?.content?.emailAttachments;
                    }
                }
            }

        }
        return activities;
    },

    async fetchChat(convId: number): Promise<IChatItems[]> {
        const requestData = {
            convId
        };
        return await HttpService.request({
            url: ChatItemsUrl,
            requestData,
        });
    },

    fetchEntitiesHighlight() {

    },

    async fetchAllTags(): Promise<Entity[]> {
        const requestData = {
            "sortCriteria": [{ "field": "name" }],
            "fields": ["name", "description", "id"]
        };

        return await HttpService.request({
            url: EntityList,
            requestData
        });
    },

    async fetchRequestTags(requestId: number): Promise<ITagsData[]> {
        const requestData = {
            "fields": [
                "listId",
                {
                    "field": "entityList.name",
                    "alias": "name"
                },
                {
                    "field": "entityList.description",
                    "alias": "description"
                }
            ],
            "criteria": [
                {
                    "field": "entityId",
                    "operand": requestId
                }
            ],
            "sortCriteria": [
                {
                    "field": "entityList.name"
                }
            ]
        };

        return await HttpService.request({
            url: EntityListMappings,
            requestData
        });
    },

    async updateRequest(
        requestId: number,
        { resolution_status, resolution_detail, tags: _entityListIds, autotagging_category }: ChatInfoForm,
        botId: number,
        botDomain: string,
        intentIds: number[]
    ) {
        const requestData = {
            criteria: [
                {
                    field: "id",
                    operator: "IN",
                    operand: [
                        requestId
                    ]
                }
            ],
            entity: {
                resolution_status,
                resolution_detail,
                _entityListIds
            }
        }

        const updatedRequest = await HttpService.request({
            url: RequestUrl,
            method: HttpMethod.PUT,
            requestData
        });
        return updatedRequest;
        // current data model does not support updating aucategorization
        if (!intentIds?.length) {
            return { updatedRequest };
        }

        const updatedAutoCategorizationCategory = await HttpService.request({
            url: UpdateAutoCategorizationCategoryUrl,
            method: HttpMethod.PUT,
            requestData: {
                requestId,
                autotagging_category,
                botId,
                botDomain,
                intentIds
            }
        });
        // API Development - In Progress
        return { updatedRequest, updatedAutoCategorizationCategory }
    },

    async fetchRequestCountPerIntent(intentId: number): Promise<IIntentRequestCount[]> {
        const requestData = {
            "fields": [
                {
                    "field": "id",
                    "fn": "Count",
                    "alias": "count"
                }
            ],
            "criteria": [
                {
                    "field": "intents.id",
                    "operand": intentId
                }
            ],
            "groupByFields": [],
            "maxCount": null
        };

        return await HttpService.request({
            url: RequestUrl,
            requestData
        });
    },

    async fetchRequestCountInSession(sessionId: number): Promise<IRequestCountInSession> {
        const requestData = {
            "criteria": [
                {
                    "field": "session_id",
                    "operand": sessionId
                }
            ],
            "offset": 0,
            "maxCount": 0,
            "needsTotalCount": true
        };

        return await HttpService.request({
            url: RequestUrl,
            requestData
        });
    },

    async fetchChannelToken(botId: number): Promise<string> {
        const requestData = {
            "fields": [
                "token"
            ],
            "criteria": [
                {
                    "field": "bots.id",
                    "operand": botId
                },
                {
                    "field": "channel_type_id",
                    "operand": 3
                }
            ],
            "maxCount": 1
        };

        const data = await HttpService.request({
            url: FetchChannelToken,
            requestData
        });

        return data?.[0].token;
    },

    async fetchCurrentMatchForPhrase(text: string, channelToken: string, botId: number, userId: string): Promise<IKLRequest> {
        const requestData = {
            text,
            userId,
            sessionVars: null,
            channelToken,
            botId,
            reqId: "10",
            isKL: true
        };
        
        const data = await HttpService.request({
            url: FetchCurrentMatchForPhrase,
            requestData
        });
        return data;
    },

    async fetchMatchedInfo(intents: number[]): Promise<IMatchedInfo[]> {
        const requestData = {
            "fields": [
                "id",
                "name",
                "global_intent_id",
                "review_status",
                "source_type",
                "domain"
            ],
            "criteria": [
                {
                    "field": "id",
                    "operator": "IN",
                    "operand": intents
                }
            ]
        };

        const data = await HttpService.request({
            url: IntentsUrl,
            requestData
        });
        return data;
    },

    async entitiesHighlight(texts: string[], entityIds: number[], botId: number): Promise<IEntityHighlight[]> {
        const requestData = {
            texts, entityIds, botId
        };

        const highlightData = await HttpService.request({
            url: EntitiesHighlightsUrl,
            requestData
        });
        return highlightData;
    },

    async createNewTag(name: string, userId: string) {
        const requestData = {
            name,
            userId,
            "description": null,
            "isPublic": true
        };

        return await HttpService.request({
            url: CreateNewTagUrl,
            requestData
        });
    },

    async fetchFlows(botId: number) {
        const requestData = {
            "fields": ["id", "name", "db_id"],
            "criteria": [
                {
                    "field": "bot_id",
                    "operand": botId
                }
            ]
        }
        return await HttpService.request({
            url: "aisera/flows",
            requestData
        });
    },

    async fetchServiceCatalogs(botId: number) {
        const requestData = {
            "fields": ["id", "title"],
            "criteria": [
                {
                    "field": "bot_id",
                    "operand": botId
                }
            ]
        }
        return await HttpService.request({
            url: "/aisera/scItems",
            requestData
        });
    },

    async fetchKBArticle(documentKey: number) {
        const requestData = {
            "fields": ["title"],
            "criteria": [
                {
                    "field": "document_key",
                    "operand": documentKey
                }
            ]
        }
        return await HttpService.request({
            url: "/aisera/kbDocuments",
            requestData
        });
    },

    async fetchKBSection(documentKey: number, contentId: number) {
        const requestData = {
            "fields": ["subject"],
            "criteria": [
                {
                    "field": "document_key",
                    "operand": documentKey
                },
                {
                    "field": "content_id",
                    "operand": contentId
                }
            ]
        }
        return await HttpService.request({
            url: "/aisera/kbSections",
            requestData
        });
    },

    async fetchKBArticles(botId: number) {
        const requestData = {
            "fields": ["id", "title"],
            "criteria": [
                {
                    "field": "bot_id",
                    "operand": botId
                }
            ]
        }
        return await HttpService.request({
            url: "/aisera/kbDocuments",
            requestData
        });
    },

    async fetchDomains() {
        const requestData = {
            "fields": ["name", "_isPurchased"]
        }
        return await HttpService.request({
            url: "aisera/domains",
            requestData
        });
    },

    async fetchConversationFeedback(requestId: number) {
        const requestData = {
            fields: ["id", "value", "correctness", "user_id", "entity_type", "fulfillment_id",
                "conversation_id", "source_type", "comments", "created_at", "updated_at",
                "override_type", "override_value", "override_id1", "override_id2", "change_history"],
            criteria: [
                {
                    field: "conversation_id",
                    operand: requestId
                }
            ],
        }
        const feedback = await HttpService.request({
            url: "aisera/requests/conversationFeedback",
            requestData
        });
        console.log(feedback)
        return feedback;
    },

    async createConversationFeedback(
        userId: string,
        requestId: number,
        entityType: string,
        entityId1: number,
        entityId2: number | null,
        correctness: string,
        value: string,
        overrideType: string | null,
        overrideId1: number | null,
        overrideId2: number | null,
        overrideValue: string | undefined,
        changeHistory: any,
        comments?: string
    ) {
        console.log(userId)
        let entity: any = {
            // "id": 9999999999999999999,
            "user_id": userId,
            "entity_type": entityType,
            "fulfillment_id": entityId1,
            // "entity_id2": entityId2,
            "conversation_id": requestId,
            "source_type": "ADMIN_UI",
            value,
            correctness,
            comments,
            "change_history": changeHistory,
            "override_id1": overrideId1,
            "override_id2": overrideId2,
            "override_value": overrideValue,
        }
        if (overrideType) entity.override_type = overrideType
        const requestData = {
            // criteria: [
            //     {
            //         field: "user_id",
            //         operator: "IN",
            //         operand: [
            //             userId
            //             // "-9220426821677790801"
            //         ]
            //     }
            // ],
            entity,
        }
        return await HttpService.request({
            url: "aisera/requests/conversationFeedback",
            method: HttpMethod.POST,
            requestData
        });
    },

    async updateConversationFeedback(
        userId: string,
        requestId: number,
        entityType: string,
        entityId1: number,
        entityId2: number | null,
        correctness: string | null,
        // newCorrectness: string,
        value: string | null,
        overrideType: string | null,
        overrideId1: number | null,
        overrideId2: number | null,
        overrideValue: string | undefined,
        changeHistory: any,
        comments?: string
    ) {
        console.log(value)
        let entity: any = {
            value,
            "fulfillment_id": entityId1,
            // "entity_id2": entityId2,
            "entity_type": entityType,
            // "entity_id": 'ffe75a1e-5df9-410e-b2bd-8006b231710c',
            correctness,
            comments,
            "change_history": changeHistory,
            "override_id1": overrideId1,
            "override_id2": overrideId2,
            "override_value": overrideValue,
        }
        if (overrideType) entity.override_type = overrideType
        const requestData = {
            criteria: [
                {
                    field: "user_id",
                    operand: userId
                },
                {
                    field: "conversation_id",
                    operand: requestId
                },
                {
                    field: "entity_type",
                    operator: "IN",
                    operand: entityType === "FLOW" || entityType === "SERVICE_CATALOGS" || entityType === "KB_ARTICLES" ? [
                        "FLOW", "SERVICE_CATALOGS", "KB_ARTICLES"
                    ] : [entityType]
                },
                // {
                //     field: "correctness",
                //     operator: "IN",
                //     operand: correctness !== "RELEVANT" && correctness !== "" ? [
                //         "IRRELEVANT", "PARTIALLY_RELEVANT", "OTHER", "NEUTRAL"
                //     ] : [correctness]
                // }
            ],
            entity,
        }
        return await HttpService.request({
            url: "aisera/requests/conversationFeedback",
            method: HttpMethod.PUT,
            requestData
        });
    },

    async deleteConversationFeedback(
        entityId: number,
        // userId: string,
        // requestId: number,
        // entityType: string,
        // entityId1: number | null,
        // // entityId2: number | null,
        // // correctness: string,
        // // newCorrectness: string,
        // // value: string,
        // overrideType: string | null,
        // overrideId1: number | null,
        // overrideId2: number | null,
        // comments?: string
    ) {
        // console.log(comments)
        const requestData = {
            // criteria: [
            //     {
            //         field: "user_id",
            //         operand: userId
            //     },
            //     {
            //         field: "conversation_id",
            //         operand: requestId
            //     },
            //     {
            //         field: "entity_type",
            //         operator: "IN",
            //         operand: entityType === "FLOW" || entityType === "SERVICE_CATALOGS" || entityType === "KB_ARTICLES" ? [
            //             "FLOW", "SERVICE_CATALOGS", "KB_ARTICLES"
            //         ] : [entityType]
            //     },
            //     // {
            //     //     field: "correctness",
            //     //     operator: "IN",
            //     //     operand: correctness !== "RELEVANT" && correctness !== "" ? [
            //     //         "IRRELEVANT", "PARTIALLY_RELEVANT", "OTHER", "NEUTRAL"
            //     //     ] : [correctness]
            //     // },
            //     {
            //         field: "entity_id",
            //         operand: entityId1
            //     },
            //     {
            //         field: "fulfillment_id",
            //         operand: entityId1
            //     },
            //     {
            //         field: "override_type",
            //         operand: overrideType
            //     },
            //     {
            //         field: "override_id1",
            //         operand: overrideId1
            //     },
            //     {
            //         field: "override_id2",
            //         operand: overrideId2
            //     },
            // ],
            // entity: {
            // value,
            // "entity_id1": entityId1,
            // "entity_id2": entityId2,
            // "entity_type": entityType,
            entityId,
            // correctness: newCorrectness,
            // comments,
            // }
        }
        return await HttpService.request({
            url: "aisera/requests/conversationFeedback",
            method: HttpMethod.DELETE,
            requestData
        });
    },

    async fetchFulfillment(requestId: number) {
        console.log(requestId)
        let requestData: any = {
            fields: ["fulfillment_id"],
            criteria: [{ field: "request_id", operand: requestId }],
        }
        const data = await HttpService.request({
            url: "aisera/requests/fulfillments",
            requestData
        });

        console.log(data)

        requestData = {
            fields: ["id", "name"],
            // criteria: [{ field: "id", operand: data.fulfillment_id }],
        }
        return await HttpService.request({
            url: "aisera/intentFulfillments",
            requestData
        });
    },

    async fetchFulfillment2(userId: string, requestId?: number, botId?: number, entityType?: string, kbId?: number) {
        let criteria = [];
        // criteria.push({
        //     field: "user_id",
        //     operator: "IN",
        //     operand: [
        //         userId
        //         // "-9220426821677790801"
        //     ]
        // })
        if (requestId) {
            criteria.push({
                field: "request_id",
                operand: requestId
            })
        }
        if (botId) {
            criteria.push({
                field: "bot_id",
                operand: botId
            })
        }
        if (entityType) {
            criteria.push({
                field:
                    entityType === "FLOW" ? "flow_db_id" :
                        entityType === "KB" ? "kb_document_key" :
                            "service_catalog_key",
                operator: "!=",
                operand: null,
            })
        }
        if (kbId) {
            criteria.push({
                field: "kb_document_key",
                operand: kbId
            })
        }
        const requestData = {
            "fields": ["created_at", "bot_id", "request_id", "Main_Request", "type", "flow_db_id", "flow_name", "kb_document_key",
                "document_title", "document_content_id", "section_title", "service_catalog_name", "service_catalog_key"],
            criteria,
        }
        return await HttpService.request({
            url: "aisera/requests/conversationFulfillmentsView",
            requestData
        });
    },

}

export default RequestDetailsService;