import Http from "../utilities/http";
import makeErrorsPretty from "../utilities/make_errors_pretty";

import type ApiAutodeskAccessToken from "../models/api/integrations/autodesk/api_access_token";
import type ApiHubs from "../models/api/integrations/autodesk/api_hubs";
import type ApiProjects from "../models/api/integrations/autodesk/api_projects";
import type {
    ApiIntegrationCredentials,
    ApiIntegrationCredentialsType,
    ApiIntegrationProject,
    ApiObservationRequest,
    ApiRunningProcess,
    User
} from "../models";
import type {AssociationIds} from "type_aliases";
import type {ApiRfiRequest} from "../models/api/integrations/procore/api_rfi_request";
import {AutodeskRequest} from "../models";
import getAuthorizationHeaders from "../utilities/get_authorization_headers";
import ApiIssueTypes from "../models/api/integrations/autodesk/api_issue_types";
import ApiAssignees from "../models/api/integrations/autodesk/api_assignees";
import {ElementIdentifiers} from "../models/api/integrations/element_identifiers";
import {IntegrationAssociationIds} from "../models/api/integrations/integration_ids";
import ApiReviztoAccessToken from "../models/api/integrations/revizto/api_access_token";
import ApiReviztoData from "../models/api/integrations/revizto/api_get_data";
import {ReviztoIssueFields} from "../models/api/integrations/revizto/api_issue_fields";
import {JiraIssueRequest} from "../models/api/integrations/jira/JiraIssueRequest";
import {ApiResponse} from "../models/api/integrations/jira/ApiResponse";
import {JiraIssueRequestModel} from "../models/api/integrations/jira/JiraIssueRequestModel";
import {FieldsConfiguration} from "../models/api/integrations/jira/FieldsConfiguration";
import {JiraAcsWorkItemRequest} from "../models/api/integrations/jira/JiraAcsWorkItemRequest";
import {JiraAcsWorkItemRequestModel} from "../models/api/integrations/jira/JiraAcsWorkItemRequestModel";
import {JiraAcsFieldsConfiguration} from "../models/api/integrations/jira/JiraAcsFieldsConfiguration";
import { PowerBIAccessTokenResponse } from "../models/api/integrations/powerbi/api_access_token";
import { EmbedTokenResponse } from "../models/api/integrations/powerbi/api_embed_token_response";
import {ApiCoordinationIssueRequest} from "../models/api/integrations/procore/api_coordination_issue_request";
import {Trade} from "../models/api/integrations/procore/Trade";
import {Location} from "../models/api/integrations/procore/Location";
import {ProcoreToolsPermissionsResponse} from "../models/api/integrations/procore/procore_tools_permissions_response";

export default class IntegrationsApi {

    static getIntegrationCredentials({
                                         organizationId,
                                         projectId
                                     }: AssociationIds,
                                     credentialType: ApiIntegrationCredentialsType,
                                     user: User): Promise<ApiIntegrationCredentials> {
        const url = `${Http.baseUrl()}/integrations/organizations/${organizationId}/projects/${projectId}/credentials/${credentialType}`;
        return Http.get(url, user) as unknown as Promise<ApiIntegrationCredentials>;
    }

    static getIntegrationProjectsForCredentials({
                                                    organizationId,
                                                    projectId
                                                }: AssociationIds,
                                                credentialType: ApiIntegrationCredentialsType,
                                                user: User): Promise<ApiIntegrationProject[]> {
        const url = `${Http.baseUrl()}/integrations/organizations/${organizationId}/projects/${projectId}/credentials/${credentialType}/projects`;
        return Http.get(url, user) as unknown as Promise<ApiIntegrationProject[]>;
    }

    static getProjectIntegrationCredentials({
                                                organizationId,
                                                projectId
                                            }: AssociationIds, user: User): Promise<ApiIntegrationCredentials[]> {
        const url = `${Http.baseUrl()}/integrations/organizations/${organizationId}/projects/${projectId}/credentials`;
        return Http.get(url, user) as unknown as Promise<ApiIntegrationCredentials[]>;
    }

    static saveIntegrationCredentials({
                                          organizationId,
                                          projectId
                                      }: AssociationIds,
                                      credentials: ApiIntegrationCredentials,
                                      user: User): Promise<ApiIntegrationCredentials> {
        const url = `${Http.baseUrl()}/integrations/organizations/${organizationId}/projects/${projectId}/credentials/${credentials.credentialsType}`;
        return Http.put(url, user, credentials) as unknown as Promise<ApiIntegrationCredentials>;
    }

    static syncIntegrationProjects({
                                       organizationId,
                                       projectId
                                   }: AssociationIds,
                                   credentialsType: ApiIntegrationCredentialsType,
                                   user: User): Promise<ApiRunningProcess> {
        const url = `${Http.baseUrl()}/integrations/organizations/${organizationId}/projects/${projectId}/credentials/${credentialsType}/sync-projects`;
        return Http.post(url, user) as unknown as Promise<ApiRunningProcess>;
    }

    static syncIntegrationPhotoAreas({
                                         organizationId,
                                         projectId
                                     }: AssociationIds,
                                     credentialsType: ApiIntegrationCredentialsType,
                                     user: User): Promise<ApiRunningProcess> {
        const url = `${Http.baseUrl()}/integrations/organizations/${organizationId}/projects/${projectId}/credentials/${credentialsType}/sync-photo-areas`;
        return Http.post(url, user) as unknown as Promise<ApiRunningProcess>;
    }

    static updateProjectIntegrationProject({
                                               organizationId,
                                               projectId
                                           }: AssociationIds,
                                           integrationProject: ApiIntegrationProject | null,
                                           user: User): Promise<void> {
        const url = `${Http.baseUrl()}/integrations/organizations/${organizationId}/projects/${projectId}/set-integration-project`;
        return Http.post(url, user, integrationProject) as unknown as Promise<void>;
    }

    static checkProcoreAccessToken(procoreAccessToken: string,
                                   user: User): Promise<{ expiresInSeconds: number }> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        let url = `${Http.baseUrl()}/integrations/procore/access-token?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<{ expiresInSeconds: number }>;
    }

    static getProcoreProjects(procoreAccessToken: string,
                              companyId: string,
                              user: User): Promise<{ lastUpdated: number, projectId: string | number }[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        let url = `${Http.baseUrl()}/integrations/procore/projects`;
        const params = [];
        params.push(`procore-access-token=${procoreAccessToken}`);
        if (companyId) {
            params.push(`companyId=${companyId}`);
        }
        url += "?" + params.join("&");
        return Http.get(url, user) as unknown as Promise<{ lastUpdated: number, projectId: string | number }[]>;
    }

    static getProcoreCompanies(procoreAccessToken: string,
                               user: User): Promise<{ name: string, id: string | number }[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        let url = `${Http.baseUrl()}/integrations/procore/companies?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<{ name: string, id: string | number }[]>;
    }

    static listProcoreObservationTypes(procoreAccessToken: string,
                                       companyId: string,
                                       user: User): Promise<{ name: string, id: string | number, category: string }[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        let url = `${Http.baseUrl()}/integrations/procore/${companyId}/observation-types?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<{ name: string, id: string | number, category: string }[]>;
    }

    static getObservationAssignees(procoreAccessToken: string,
                           companyId: string,
                           projectId: string,
                           user: User): Promise<{ name: string, id: string | number }[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        let url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/observation-assignees?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<{ name: string, id: string | number }[]>;
    }

    static getAllProcoreToolsPermissions(procoreAccessToken: string,
                                        companyId: string,
                                        projectId: string,
                                        user: User): Promise<ProcoreToolsPermissionsResponse> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        let url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/procore-tools-permissions?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<ProcoreToolsPermissionsResponse>;
    }

    static getRfiAssignees(procoreAccessToken: string,
                           companyId: string,
                           projectId: string,
                           user: User): Promise<{ name: string, id: string | number }[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        let url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/rfi-assignees?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<{ name: string, id: string | number }[]>;
    }

    static getRfiManagers(procoreAccessToken: string,
                           companyId: string,
                           projectId: string,
                           user: User): Promise<{ name: string, id: string | number }[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        let url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/rfi-managers?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<{ name: string, id: string | number }[]>;
    }

    static CreateProcoreObservation(procoreAccessToken: string,
                                    companyId: string,
                                    projectId: string,
                                    observationRequest: ApiObservationRequest,
                                    ids: IntegrationAssociationIds,
                                    imageBlob: Blob,
                                    user: User): Promise<number> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        if (!imageBlob) {
            return Promise.reject(new Error("Invalid imageBlob"));
        }

        const formData = new FormData();
        formData.append("observationRequest", JSON.stringify(observationRequest));
        formData.append("associationIds",JSON.stringify(ids));
        formData.append("attachments", imageBlob, "image.png");

        const url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/create-observation-with-attachment?procore-access-token=${procoreAccessToken}`;

        return Http.fetch(url, {
            method: "POST",
            headers: {
                ...getAuthorizationHeaders(user)
            },
            body: formData
        }) as unknown as Promise<number>;

    }

    static CreateProcoreCoordinationIssueWithAttachments(procoreAccessToken: string,
                                                         companyId: string,
                                                         projectId: string,
                                                         coordinationIssueRequest: ApiCoordinationIssueRequest,
                                                         ids: IntegrationAssociationIds,
                                                         imageBlob: Blob,
                                                         user: User): Promise<number> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        if (!imageBlob) {
            return Promise.reject(new Error("Invalid imageBlob"));
        }
        if (!coordinationIssueRequest || coordinationIssueRequest?.title?.length === 0) {
            return Promise.reject(new Error("Invalid coordinationIssueRequest or Missing title"));
        }

        const url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/create-coordination-issue-with-attachments?procore-access-token=${procoreAccessToken}`;

        const formData = new FormData();
        formData.append("coordinationIssueRequest", JSON.stringify(coordinationIssueRequest));
        formData.append("associationIds",JSON.stringify(ids));
        formData.append("attachments", imageBlob, "image.png");

        return Http.fetch(url, {
            method: "POST",
            headers: {
                ...getAuthorizationHeaders(user)
            },
            body: formData
        }) as unknown as Promise<number>;

    }

    static getProcoreTradesForCoordinateIssue(procoreAccessToken: string, companyId: string, user: User): Promise<Trade[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        const url = `${Http.baseUrl()}/integrations/procore/${companyId}/trades?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<Trade[]>;
    }

    static getProcoreCoordinationIssueAssigness(procoreAccessToken: string, companyId: string, projectId: string, user: User): Promise<{ name: string, id: string | number }[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        const url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/coordination-issue-assignees?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<{ name: string, id: string | number }[]>;
    }

    static getProcoreLocationsForCoordinateIssue(procoreAccessToken: string, companyId: string, projectId: string, user: User): Promise<Location[]> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        const url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/locations?procore-access-token=${procoreAccessToken}`;
        return Http.get(url, user) as unknown as Promise<Location[]>;
    }

    static CreateProcoreRfi(procoreAccessToken: string,
                            companyId: string,
                            projectId: string,
                            rfiRequest: ApiRfiRequest,
                            ids: IntegrationAssociationIds,
                            imageBlob: Blob,
                            user: User): Promise<number> {
        if (!procoreAccessToken) {
            return Promise.reject(new Error("Procore access token not found"));
        }
        if (!projectId) {
            return Promise.reject(new Error("project id not found"));
        }
        if (!companyId) {
            return Promise.reject(new Error("company id not found"));
        }
        if (!imageBlob) {
            return Promise.reject(new Error("Invalid imageBlob"));
        }

        let url = `${Http.baseUrl()}/integrations/procore/${companyId}/${projectId}/create-rfi-with-attachments?procore-access-token=${procoreAccessToken}`;

        const modifiedRfiRequest = {
            ...rfiRequest,
            private: rfiRequest.personal
        };
        delete modifiedRfiRequest.personal;

        const formData = new FormData();
        formData.append("rfiRequest", JSON.stringify(modifiedRfiRequest));
        formData.append("associationIds",JSON.stringify(ids));
        formData.append("attachments", imageBlob, "image.png");

        return Http.fetch(url, {
            method: "POST",
            headers: {
                ...getAuthorizationHeaders(user)
            },
            body: formData
        }) as unknown as Promise<number>;
    }

    static getAutodeskAccessToken(code: string, redirectUri: string, user: User): Promise<ApiAutodeskAccessToken> {
        if (!code || !redirectUri) {
            return Promise.reject(new Error("Invalid client secret or redirectUri"));
        }
        const url = `${Http.baseUrl()}/integrations/autodesk/access-token?code=${code}&redirect-uri=${redirectUri}`;
        return Http.get(url, user) as unknown as Promise<ApiAutodeskAccessToken>;
    }

    static getAutodeskHubs(access_token: string, user: User): Promise<ApiHubs> {
        if (!access_token) {
            return Promise.reject(new Error("Invalid access token"));
        }
        const url = `${Http.baseUrl()}/integrations/autodesk/hubs?access-token=${access_token}`;
        return Http.get(url, user) as unknown as Promise<ApiHubs>;
    }

    static getAutodeskProjects(access_token: string, hubId: string, user: User): Promise<ApiProjects> {
        if (!access_token || !hubId) {
            return Promise.reject(new Error("Invalid access token or hubId"));
        }
        const url = `${Http.baseUrl()}/integrations/autodesk/projects?access-token=${access_token}&hubId=${hubId}`;
        return Http.get(url, user) as unknown as Promise<ApiProjects>;
    }

    static getAutodeskIssueTypes(access_token: string, projectId: string, user: User): Promise<ApiIssueTypes> {
        if (!access_token || !projectId) {
            return Promise.reject(new Error("Invalid access token or projectId"));
        }
        const url = `${Http.baseUrl()}/integrations/autodesk/issue-types?access-token=${access_token}&projectId=${projectId}`;
        return Http.get(url, user) as unknown as Promise<ApiIssueTypes>;
    }

    static getAutodeskIssueAssignees(access_token: string, projectId: string, user: User): Promise<ApiAssignees[]> {
        if (!access_token || !projectId) {
            return Promise.reject(new Error("Invalid access token or projectId"));
        }
        const url = `${Http.baseUrl()}/integrations/autodesk/assignees?access-token=${access_token}&projectId=${projectId}`;
        return Http.get(url, user) as unknown as Promise<ApiAssignees[]>;
    }

    static createAutodeskRequest(access_token: string, hubId: string, projectId: string, autodeskRequest: AutodeskRequest, imageBlob: Blob, ids:IntegrationAssociationIds, user: User): Promise<number> {
        if (!access_token) {
            return Promise.reject(new Error("Invalid access token"));
        }
        if (!hubId) {
            return Promise.reject(new Error("Invalid hubId"));
        }
        if (!projectId) {
            return Promise.reject(new Error("Invalid projectId"));
        }
        if (!autodeskRequest) {
            return Promise.reject(new Error("Invalid autodeskRequest"));
        }
        if (!imageBlob) {
            return Promise.reject(new Error("Invalid imageBlob"));
        }
        if (!user) {
            return Promise.reject(new Error("Invalid user"));
        }

        const formData = new FormData();
        formData.append("hubId", hubId);
        formData.append("projectId", projectId);
        formData.append("access-token", access_token);
        formData.append("autodeskRequest", JSON.stringify(autodeskRequest));
        formData.append("associationIds", JSON.stringify(ids));
        formData.append("image", imageBlob, "image.png");

        const url = `${Http.baseUrl()}/integrations/autodesk/create-request`;

        return Http.fetch(url, {
            method: "POST",
            headers: {
                ...getAuthorizationHeaders(user)
            },
            body: formData
        }) as unknown as Promise<number>;
    }

    static getReviztoAccessToken(code: string, region: string, user: User): Promise<ApiReviztoAccessToken> {
        if (!code || !region) {
            return Promise.reject(new Error("Invalid code or region"));
        }
        const url = `${Http.baseUrl()}/integrations/revizto/access-token?code=${code}&region=${region}`;
        return Http.get(url, user) as unknown as Promise<ApiReviztoAccessToken>;
    }

    static getReviztoData(accessToken: string, region: string, user: User): Promise<ApiReviztoData> {
        if (!accessToken || !region) {
            return Promise.reject(new Error("Invalid access token or region"));
        }
        const url = `${Http.baseUrl()}/integrations/revizto/get-data?access-token=${accessToken}&region=${region}`;
        return Http.get(url, user) as unknown as Promise<ApiReviztoData>;
    }

    static createReviztoIssue(
        reviztoAccesstoken: string,
        region: string,
        preview: Blob,
        fields: ReviztoIssueFields,
        uuid: string,
        projectId: string,
        selectedElementIds: IntegrationAssociationIds,
        user: User
    ): Promise<Response> {
        if (!reviztoAccesstoken || !region || !preview || !fields || !uuid || !projectId ) {
            return Promise.reject(new Error("Invalid input parameters"));
        }

        const formData = new FormData();
        formData.append("preview", preview);
        formData.append("fields", JSON.stringify(fields));
        formData.append("uuid", uuid);
        formData.append("projectId", projectId);
        formData.append("access-token", reviztoAccesstoken);
        formData.append("region", region);
        formData.append("associationIds", JSON.stringify(selectedElementIds));

        const url = `${Http.baseUrl()}/integrations/revizto/create-request`;

        return Http.fetch(url, {
            method: "POST",
            headers: {
                ...getAuthorizationHeaders(user),
            },
            body: formData,
        }) as unknown as Promise<Response>;
    }

    static getPowerBIAccessToken(user: User): Promise<PowerBIAccessTokenResponse> {
        const url = `${Http.baseUrl()}/integrations/powerbi/accessToken`;
        return Http.get(url, user) as unknown as Promise<PowerBIAccessTokenResponse>;
    }

    static getPowerBIEmbedToken(groupId: string, reportId: string, user: User): Promise<EmbedTokenResponse> {
        if (!groupId || !reportId) {
            return Promise.reject(new Error("Invalid groupId or reportId"));
        }
        const url = `${Http.baseUrl()}/integrations/powerbi/embedToken/groups/${groupId}/reports/${reportId}`;
        return Http.get(url, user) as unknown as Promise<EmbedTokenResponse>;
    }

    static getAllCreatedIssuesForDeviatedElements(user: User, ids: ElementIdentifiers[]): Promise<{ toolName: string, issueId: string, id:number }[]> {
        let url = `${Http.baseUrl()}/integrations/tools/issues`;
        return Http.post(url,user, ids) as unknown as Promise<{ toolName: string, issueId: string, id:number }[]>;
    }

    static createJiraServiceDeskTicket(jiraIssueRequestModel: JiraIssueRequestModel,
                                     user: User): Promise<ApiResponse> {
        if (jiraIssueRequestModel) {
            const url = `${Http.baseUrl()}/integrations/jira/create-ticket`;
            const jiraIssueRequest = new JiraIssueRequest(jiraIssueRequestModel);
            return Http.post(url, user, jiraIssueRequest) as unknown as Promise<ApiResponse>;
        }
    }

    static getJiraFieldsConfiguration(user: User): Promise<FieldsConfiguration> {
        const url = `${Http.baseUrl()}/integrations/jira/configuration`;
        return Http.get(url, user) as unknown as Promise<FieldsConfiguration>;
    }

    static createJiraAcsWorkItem(jiraAcsWorkItemRequestModel: JiraAcsWorkItemRequestModel,
                                 user: User): Promise<ApiResponse> {
        const url = `${Http.baseUrl()}/integrations/jira/acs/create-work-item`;
        const jiraAcsWorkItemRequest = new JiraAcsWorkItemRequest(jiraAcsWorkItemRequestModel);
        return Http.post(url, user, jiraAcsWorkItemRequest) as unknown as Promise<ApiResponse>;
    }

    static getJiraAcsWorkItemFieldsConfiguration(user: User): Promise<JiraAcsFieldsConfiguration> {
        const url = `${Http.baseUrl()}/integrations/jira/acs/configuration`;
        return Http.get(url, user) as unknown as Promise<JiraAcsFieldsConfiguration>;
    }
}

makeErrorsPretty(IntegrationsApi);