import { useState, useEffect, useContext, useId } from "react";
import general from "../../common/General/General";
import { ICriteria } from "../../components/SearchBar/SearchBar.type";
import { QuestContext } from "../../context/QuestContext";

interface SearchBarParams {
  questId: string;
  questUserId?: string;
  userToken?: string;
  userId?: string;
  variation?: string;
  onError?: (event: "GET_CAPAINGN_ACTIONS", message: string, data?: {}) => void;
}

function useSearchBar({
  questId,
  questUserId,
  userToken,
  userId,
  variation,
  onError,
}: SearchBarParams) {
  const { apiKey, entityId, authenticationToken } = useContext(QuestContext);
  const [criterias, setCriterias] = useState<ICriteria[]>([]);
  const [loading, setLoading] = useState(true);
  const [session, setSession] = useState(null);
  const [questDetails, setQuestDetails] = useState({
    campaignVariationId: "",
  });
  const [credentials, setCredentials] = useState({
    userId: questUserId,
    token: userToken,
  });

  async function fetchData(userId: string, token: string) {
    try {
      const response = await general.makeRequest({
        url: `/v2/entities/${entityId}/campaigns/${questId}?variation=${
          variation || "default"
        }`,
        method: "GET",
        headers: {
          "Content-Type": "application/json",
          userId: userId,
          token: token,
          apiKey,
        },
      });

      if (!response.success) {
        if (onError) {
          onError("GET_CAPAINGN_ACTIONS", response.error, response);
        }
      }

      const fetchedCriterias =
        response?.data?.actions?.map((criteria: any) => ({
          actionId: criteria.actionId,
          title: criteria.title,
          postlink: criteria.metadata.link,
          imageUrl: criteria.metadata.imageUrl,
          description: criteria.description,
        })) || [];

      setCriterias(fetchedCriterias);

      setSession(response?.data?.session || null);
      setQuestDetails({
        campaignVariationId: response?.data?.campaignVariationId,
      });
    } catch (error: any) {
      if (onError) {
        onError("GET_CAPAINGN_ACTIONS", error.message);
      }
    }
  }

  async function externalLogin() {
    try {
      const response = await general.makeRequest({
        url: `/users/external/login`,
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          apiKey,
          entityId,
          "entity-authentication-token": authenticationToken,
        },
        body: {
          externalUserId: userId,
          entityId,
        },
      });

      if (response.userId && response.token) {
        setCredentials({
          userId: response.userId,
          token: response.token,
        });
      }
      return response;
    } catch (error) {
      console.error("Error fetching data:", error);
    }
  }

  useEffect(() => {
    if (questUserId && userToken) {
      (async () => {
        await fetchData(questUserId, userToken);
        setLoading(false);
      })();
    } else if (userId) {
      (async () => {
        let credentials = await externalLogin();
        await fetchData(credentials.userId, credentials.token);
        setLoading(false);
      })();
    }
  }, [questUserId, userToken, userId]);

  return {
    actions: criterias,
    loading,
    sessionId: session,
    campaignVariationId: questDetails.campaignVariationId,
    questId,
    questUserId: credentials.userId,
    userToken: credentials.token,
  };
}

export default useSearchBar;