"use server";
import axios from "axios";
import { updateAddress } from "./addressActions";

interface AddressResponse {
  success: boolean;
  message?: string;
  data?: any;
  error?: any; // Add error field for validation errors
}

export async function fetchAddressesAction(
  token: string,
  locale: string
): Promise<AddressResponse> {
  try {
    const response = await axios.get(
      `${process.env.NEXT_PUBLIC_API_URL}/addresses`,
      {
        headers: {
          Authorization: `Bearer ${token}`,
          "Accept-Language": locale,
          "Content-Type": "application/json",
          Accept: "application/json",
        },
      }
    );

    if (
      response.data &&
      (response.data.success_type === "ADDRESS_LIST_FETCH" ||
        response.data.success)
    ) {
      const apiAddresses = response.data.data?.data || response.data.data || [];

      if (!Array.isArray(apiAddresses)) {
        return { success: false, message: "Invalid address data format" };
      }

      const transformedAddresses = apiAddresses
        .map((addr: any) => ({
          _id: addr.id,
          name: addr.address_line_1,
          address: `${addr.short_address ? addr.short_address + ", " : ""}${
            addr.building_name ? addr.building_name + ", " : ""
          }${addr.street ? addr.street + ", " : ""}${
            addr.secondary_number ? addr.secondary_number + ", " : ""
          }${addr.district ? addr.district + ", " : ""}${
            addr.address_line_1 || ""
          }${addr.address_line_2 ? ", " + addr.address_line_2 : ""}, ${
            addr.city?.name || ""
          }, ${addr.state?.name || ""}`,
          phone:
            addr.country_code && addr.contact_number
              ? `${addr.country_code}${addr.contact_number}`
              : addr.contact_number || addr.phone || "",
          short_address: addr.short_address,
          building_name: addr.building_name,
          street: addr.street,
          secondary_number: addr.secondary_number,
          district: addr.district,
          address_line_1: addr.address_line_1,
          address_line_2: addr.address_line_2,
          city: addr.city,
          state: addr.state,
          country: addr.country,
          postal_code: addr.postal_code,
          address_type: addr.address_type,
          isPrimary: addr.isPrimary ?? addr.is_primary,
        }))
        .reverse();

      return { success: true, data: transformedAddresses };
    } else {
      return { success: false, message: "Failed to fetch addresses" };
    }
  } catch (error: any) {
    return {
      success: false,
      message: error?.response?.data?.message || "Failed to fetch addresses",
    };
  }
}

export async function storeAddressAction(
  addressData: any,
  token: string,
  locale: string
): Promise<AddressResponse> {
  try {
    const response = await axios.post(
      `${process.env.NEXT_PUBLIC_API_URL}/address/store`,
      addressData,
      {
        headers: {
          Authorization: `Bearer ${token}`,
          "Accept-Language": locale,
          "Content-Type": "application/json",
          Accept: "application/json",
        },
      }
    );

    if (response.data && response.data.success_type === "ADDRESS_STORE") {
      const newAddress = {
        _id: response.data.data.addressData?._id,
        name: addressData.address_line_1 || "My Place",
        address: `${
          addressData.short_address ? addressData.short_address + ", " : ""
        }${addressData.building_name ? addressData.building_name + ", " : ""}${
          addressData.street ? addressData.street + ", " : ""
        }${
          addressData.secondary_number
            ? addressData.secondary_number + ", "
            : ""
        }${addressData.district ? addressData.district + ", " : ""}${
          addressData.address_line_1
        }${
          addressData.address_line_2 ? ", " + addressData.address_line_2 : ""
        }, ${addressData.city?.name || ""}, ${addressData.state?.name || ""}`,
        phone:
          addressData.alternate_country_code &&
          addressData.alternate_address_contact_number
            ? `${addressData.alternate_country_code}${addressData.alternate_address_contact_number}`
            : addressData.alternate_address_contact_number || "",
        country_code: addressData.alternate_country_code,
        contact_number: addressData.alternate_address_contact_number,
        short_address: addressData.short_address,
        building_name: addressData.building_name,
        street: addressData.street,
        secondary_number: addressData.secondary_number,
        district: addressData.district,
        address_line_1: addressData.address_line_1,
        address_line_2: addressData.address_line_2,
        city: addressData.city,
        state: addressData.state,
        postal_code: addressData.postal_code,
        address_type: addressData.address_type ,
        isPrimary: addressData.isPrimary || false,
      };

      return {
        success: true,
        data: newAddress,
        message: "Address added successfully",
      };
    } else {
      // Check if there are validation errors in the response
      if (response.data && response.data.error) {
        return {
          success: false,
          message: response.data.message || "Validation Error",
          error: response.data.error
        };
      }
      return { success: false, message: "Failed to add address" };
    }
  } catch (error: any) {
    // Check if the error response contains validation errors
    if (error?.response?.data?.error) {
      return {
        success: false,
        message: error?.response?.data?.message || "Validation Error",
        error: error.response.data.error
      };
    }
    return {
      success: false,
      message: error?.response?.data?.message || "Failed to add address"
    };
  }
}

export async function updateAddressAction(
  addressId: string,
  addressData: any,
  token: string,
  locale: string
): Promise<AddressResponse> {
  try {
    const response = await axios.post(
      `${process.env.NEXT_PUBLIC_API_URL}/address/${addressId}/update`,
      addressData,
      {
        headers: {
          Authorization: `Bearer ${token}`,
          "Accept-Language": locale,
          "Content-Type": "application/json",
          Accept: "application/json",
        },
      }
    );

    if (response.data && response.data.success_type === "ADDRESS_UPDATE") {
      const updatedAddress = {
        _id: addressId,
        name: addressData.address_line_1 || "My Place",
        address: `${
          addressData.short_address ? addressData.short_address + ", " : ""
        }${addressData.building_name ? addressData.building_name + ", " : ""}${
          addressData.street ? addressData.street + ", " : ""
        }${
          addressData.secondary_number
            ? addressData.secondary_number + ", "
            : ""
        }${addressData.district ? addressData.district + ", " : ""}${
          addressData.address_line_1
        }${
          addressData.address_line_2 ? ", " + addressData.address_line_2 : ""
        }, ${addressData.city?.name || ""}, ${addressData.state?.name || ""}`,
        phone:
          addressData.alternate_country_code &&
          addressData.alternate_address_contact_number
            ? `${addressData.alternate_country_code}${addressData.alternate_address_contact_number}`
            : addressData.alternate_address_contact_number || "",
        country_code: addressData.alternate_country_code,
        contact_number: addressData.alternate_address_contact_number,
        short_address: addressData.short_address,
        building_name: addressData.building_name,
        street: addressData.street,
        secondary_number: addressData.secondary_number,
        district: addressData.district,
        address_line_1: addressData.address_line_1,
        address_line_2: addressData.address_line_2,
        city: addressData.city,
        state: addressData.state,
        postal_code: addressData.postal_code,
        address_type: addressData.address_type ,
        isPrimary: addressData.isPrimary || false,
      };
      return {
        success: true,
        data: updatedAddress,
        message: "Address updated successfully"
      };
      
    } else {
      // Check if there are validation errors in the response
      if (response.data && response.data.error) {
        return {
          success: false,
          message: response.data.message || "Validation Error",
          error: response.data.error
        };
      }
      return { success: false, message: "Failed to update address" };
    }
  } catch (error: any) {
    // Check if the error response contains validation errors
    if (error?.response?.data?.error) {
      return {
        success: false,
        message: error?.response?.data?.message || "Validation Error",
        error: error.response.data.error
      };
    }
    return {
      success: false,
      message: error?.response?.data?.message || "Failed to update address",
    };
  }
}

export async function deleteAddressAction(
  addressId: string,
  token: string,
  locale: string
): Promise<AddressResponse> {
  try {
    const response = await axios.delete(
      `${process.env.NEXT_PUBLIC_API_URL}/address/${addressId}/delete`,
      {
        headers: {
          Authorization: `Bearer ${token}`,
          "Accept-Language": locale,
          "Content-Type": "application/json",
          Accept: "application/json",
        },
      }
    );

    if (response.data && response.data.success_type === "ADDRESS_DELETE") {
      return {
        success: true,
        data: addressId,
        message: "Address deleted successfully",
      };
    } else {
      return { success: false, message: "Failed to delete address" };
    }
  } catch (error: any) {
    return {
      success: false,
      message: error?.response?.data?.message || "Failed to delete address",
    };
  }
}

export async function setPrimaryAddress(
  addressId: string,
  token: string
): Promise<AddressResponse> {
  try {
    const response = await axios.get(
      `${process.env.NEXT_PUBLIC_API_URL}/address/${addressId}/set-primary`,
      {
        headers: {
          Authorization: `Bearer ${token}`,
          "Accept-Language": "en",
          "Content-Type": "application/json",
          Accept: "application/json",
        },
      }
    );

    if (response?.data?.success_type === "PRIMARY_ADDRESS") {
      return {
        success: true,
        message:
          response.data.message || "Primary address updated successfully",
        data: response.data.data,
      };
    }

    return {
      success: false,
      message: response?.data?.message || "Failed to set primary address",
    };
  } catch (error: any) {
    return {
      success: false,
      message:
        error.response?.data?.message ||
        "An error occurred while setting primary address",
    };
  }
}