import axios from "axios";

import { Injectable, ServiceUnavailableException } from "@nestjs/common";
import { CMSFieldType } from "./dto/onboard-config.dto";
import { NewJurisdictionFieldDto } from "src/admin/dtos/create-jurisdiction-fields.dto";
import { IOnboardOnchainForm } from "src/common/interfaces";

const CMS_BASE_URL = process.env.CMS_BASE_URL;

const cmsPayloadConfig = {
  headers: {
    "Content-Type": "application/json",
    Authorization: `bearer ${process.env.CMS_API_KEY}`,
  },
};

@Injectable()
export class UserCmsService {
  async getOnboardConfigOfDealer(dealerEmail: string) {
    try {
      const url = `${CMS_BASE_URL}/api/users?filters[$and][0][email][$eq]=${dealerEmail.toLowerCase()}&populate=deep`;
      const response = await axios.get(url, cmsPayloadConfig);
      if (!response) {
        return null;
      }
      const data = response.data;
      return data[0];
    } catch (error) {
      throw new ServiceUnavailableException(error.message);
    }
  }

  async getEditableFormOfDealer(dealerEmail: string) {
    try {
      const url = `${CMS_BASE_URL}/api/users?filters[$and][0][email][$eq]=${dealerEmail.toLowerCase()}&populate[1]=onboard_editable_form&populate[onboard_editable_form][populate]=*`;
      const response = await axios.get(url, cmsPayloadConfig);
      if (!response) {
        return null;
      }
      const data = response.data;
      return data[0];
    } catch (error) {
      throw new ServiceUnavailableException(error.message);
    }
  }

  async getOnboardOnchainFields() {
    try {
      const url = `${CMS_BASE_URL}/api/onboard-onchain-forms/1?populate=deep`;
      const response = await axios.get(url, cmsPayloadConfig);
      if (!response) {
        return null;
      }
      return response.data;
    } catch (error) {
      throw new ServiceUnavailableException(error.message);
    }
  }

  async addNewOnchainFields(
    onboardOnchainForm: IOnboardOnchainForm,
    onchainFields: NewJurisdictionFieldDto[],
  ) {
    try {
      const isFieldDuplicated: Record<string, boolean> = {};
      onboardOnchainForm.attributes.onboard_onchain_fields.forEach((field) => {
        isFieldDuplicated[field.name] = true;
      });
      const newOnChainFields = onchainFields
        .filter((field) => isFieldDuplicated[field.dataFieldLinkedName])
        .map((field, index) => {
          return {
            __temp_key__: index + 1,
            name: field.dataFieldLinkedName,
            label: field.dataFieldLinkedName,
          };
        });

      onboardOnchainForm.attributes.onboard_onchain_fields = [
        ...onboardOnchainForm.attributes.onboard_onchain_fields,
        ...newOnChainFields,
      ];

      const url = `${CMS_BASE_URL}/api/onboard-onchain-forms/1`;
      const onboardOnchainFormPayload = {
        data: onboardOnchainForm.attributes,
      };

      await axios.put(url, onboardOnchainFormPayload, cmsPayloadConfig);
    } catch (error) {
      throw new ServiceUnavailableException(error.message);
    }
  }

  async updateOnboardEditableFields(
    dealerEmail: string,
    onboardFields: CMSFieldType[],
    formId: number,
  ) {
    try {
      const onboardConfigOfUser = await this.getEditableFormOfDealer(
        dealerEmail,
      );
      if (!onboardConfigOfUser) {
        return null;
      }
      /**
       * This ensures that only the dealer who has created the form can edit it
       */
      if (onboardConfigOfUser.onboard_editable_form.id !== formId) {
        return null;
      }
      const url = `${CMS_BASE_URL}/api/onboard-editable-forms/${formId}`;
      const onboardFieldPayload = {
        data: {
          onboard_editable_fields: onboardFields,
        },
      };
      await axios.put(url, onboardFieldPayload, cmsPayloadConfig);
    } catch (error) {
      throw new ServiceUnavailableException(error.message);
    }
  }

  async addUserInCms(email: string) {
    try {
      const password = email + "@secret";
      const userCreationPayload = {
        confirmed: true,
        onboard_fixed_form: {
          connect: [
            {
              id: Number(process.env.CMS_FIXED_FORM_ID),
              position: {
                end: true,
              },
            },
          ],
        },
        onboard_onchain_form: {
          connect: [
            {
              id: Number(process.env.CMS_ONCHAIN_FORM_ID),
              position: {
                end: true,
              },
            },
          ],
        },
        username: email,
        email: email,
        password: password,
      };
      const url = `${CMS_BASE_URL}/api/auth/local/register`;
      const result = await axios.post(
        url,
        userCreationPayload,
        cmsPayloadConfig,
      );
      if (!result) {
        return null;
      }
      this.createEditableFormForUser(result.data.user.id);
    } catch (error) {
      throw new ServiceUnavailableException(error.message);
    }
  }

  async createEditableFormForUser(userId: number) {
    try {
      const editableFieldsPayload = {
        data: {
          user: userId,
        },
      };
      const url = `${CMS_BASE_URL}/api/onboard-editable-forms`;
      await axios.post(url, editableFieldsPayload, cmsPayloadConfig);
    } catch (error) {
      throw new ServiceUnavailableException(error.message);
    }
  }

  async removeUserFromCms(email: string): Promise<void> {
    try {
      const user = await this.getOnboardConfigOfDealer(email);
      if (!user) {
        return null;
      }
      const url = `${CMS_BASE_URL}/api/users/${user.id}`; // delete user API
      await axios.delete(url, cmsPayloadConfig);
    } catch (error) {
      throw new ServiceUnavailableException(error.message);
    }
  }
}