import { getApiToken } from "../config";
import { User, UserApi, UserApiResponse } from "../definitions/models";
import createAxiosInstance from "./axios";

interface SearchUserResponse {
  meta: {
    filter_count: number;
  };
}
export const isUserRegistered = async ({ email }: { email: string }): Promise<boolean> => {
  try {
    const ACCESS_TOKEN = getApiToken();

    const axiosStrava = createAxiosInstance(ACCESS_TOKEN);

    const {
      data: { meta },
    } = await axiosStrava.get<SearchUserResponse>(`/users?filter[email][_eq]=${email}&meta=filter_count`);
    return !!meta.filter_count;
  } catch (error) {
    console.error("No se ha podido comprobar si el usuario está registrado:", error);
    throw new Error("No se ha podido comprobar si el usuario está registrado.");
  }
};

type AuthLoginResponse = {
  data: {
    expires: number;
    refresh_token: string;
    access_token: string;
  };
};
export const getCurrentUser = async ({ email, password }: { email: string; password: string }): Promise<User> => {
  try {
    const axiosAuthInstance = createAxiosInstance(null);

    const { data } = await axiosAuthInstance.post<AuthLoginResponse>("/auth/login", {
      email,
      password,
    });

    const { access_token, refresh_token, expires } = data.data;

    const axiosCurrentUserInstance = createAxiosInstance(access_token);

    const userResponse = await axiosCurrentUserInstance.get<UserApiResponse>("/users/me");
    const userApiData = userResponse.data.data as UserApi;
    return {
      id: userApiData.id,
      first_name: userApiData.first_name,
      last_name: userApiData.last_name,
      access_token,
      refresh_token,
      expires_at: Math.floor(Date.now() / 1000) + 21600000 / 1000,
      expires_in: expires,

      strava: {
        id: userApiData.id_strava,
        access_token: userApiData.access_token,
        refresh_token: userApiData.refresh_token,
        username: userApiData.username,
        avatar: userApiData.avatar_strava,
        expires_at: userApiData.expires_at,
        expires_in: userApiData.expires_in,
      },
    };
  } catch (error) {
    console.error("No se pudo obtener la información del usuario:", error);
    throw new Error("No se pudo obtener la información del usuario.");
  }
};

type UserUpdateProps = {
  access_token: string;
  expires_at: number;
  expires_in: number;
  refresh_token: string;
};

export const updateUser = async ({ userId, payload }: { userId: string; payload: UserUpdateProps }): Promise<User> => {
  try {
    const TOKEN = getApiToken();
    const axiosAuthInstance = createAxiosInstance(TOKEN);

    await axiosAuthInstance.patch(`/users/${userId}`, {
      access_token: payload.access_token,
      expires_at: payload.expires_at,
      expires_in: payload.expires_in,
      refresh_token: payload.refresh_token,
    });

    const userResponse = await axiosAuthInstance.get<UserApiResponse>("/users/me");
    const userApiData = userResponse.data.data as UserApi;

    return {
      id: userApiData.id,
      first_name: userApiData.first_name,
      last_name: userApiData.last_name,
      access_token: userApiData.access_token,
      refresh_token: userApiData.refresh_token,
      expires_at: userApiData.expires_at,
      expires_in: userApiData.expires_in,
      strava: {
        id: userApiData.id_strava,
        access_token: userApiData.access_token,
        refresh_token: userApiData.refresh_token,
        username: userApiData.username,
        avatar: userApiData.avatar_strava,
        expires_at: userApiData.expires_at,
        expires_in: userApiData.expires_in,
      },
    };
  } catch (error) {
    console.error("No se pudo actualizar el usuario:", error);
    throw new Error("No se pudo actualizar el usuario.");
  }
};