import { usePublicApi } from '..';

import type {
  ApiParams,
  CustomerResponse,
  SignupCustomer,
  SigninCustomerByDocument,
  SigninCustomerByEmail,
  ResponseSigninCustomer,
  CheckCustomer,
  ChangePasswordCustomerAuthenticated,
  UpdateCustomer,
  PasswordRecoveryCustomer,
  CustomerFields,
  CustomerSortFields,
  CustomerConditionFields,
  ChangePasswordCustomerByCode,
  UpsertCustomerAddressRequest,
  CustomerAddressResponse,
  CustomerAddressesResponse,
  CustomerOrderResponse,
  CustomerOrderGroupFields,
  CustomerOrderGroupConditionFields,
  CustomerOrderGroupSortFields,
  CustomerOrderItemHistoriesResponse,
  CustomerOrdersResponse,
  CustomerOrderItemHistorySortFields,
  CustomerOrderItemHistoryConditionFields,
  CustomerHistoryResponse,
  CustomerHistorySortFields,
  CustomerHistoryConditionFields,
  AddCustomerToNewsletterRequest,
  AddCustomerToNewsletterResponse,
  CheckCustomerResponse,
  UpdateCustomerDocument,
  UpdateCustomerDocumentResponse,
  ProductFields,
  CustomerWishlistConditionFields,
  CustomerWishlistSortFields,
  CustomerListWishlistResponse,
  CustomerDetailWishlistResponse,
  AddProductToWishlistRequest,
  RequestSendMFA
} from '../types';
import { type SalesChannelByEmailResponse } from '../types/endpoints/customer/customer.interfaces';

export function detail(
  options?: Pick<
    ApiParams<CustomerFields, CustomerSortFields, CustomerConditionFields>,
    'condition' | 'fields' | 'order'
  >,
) {
  return usePublicApi<
    CustomerResponse,
    CustomerFields,
    CustomerSortFields,
    CustomerConditionFields
  >({ endpoint: '/customer', params: options });
}

export function signup(payload: SignupCustomer) {
  return usePublicApi<CustomerResponse>({
    endpoint: '/customer',
    method: 'POST',
    payload,
  });
}

export function signinByEmail(payload: SigninCustomerByEmail) {
  return usePublicApi<ResponseSigninCustomer>({
    endpoint: '/customer/login/email',
    method: 'POST',
    payload,
  });
}

export function signinByDocument(payload: SigninCustomerByDocument) {
  return usePublicApi<ResponseSigninCustomer>({
    endpoint: '/customer/login/document',
    method: 'POST',
    payload,
  });
}

export function check(payload: CheckCustomer) {
  return usePublicApi<CheckCustomerResponse>({
    endpoint: '/customer/login/check',
    method: 'POST',
    payload,
  });
}

export function update(payload: UpdateCustomer) {
  return usePublicApi<CustomerResponse>({
    endpoint: '/customer',
    method: 'PUT',
    payload,
  });
}

export function updateDocument(payload: UpdateCustomerDocument) {
  return usePublicApi<UpdateCustomerDocumentResponse>({
    endpoint: '/customer/document',
    method: 'PUT',
    payload,
  });
}

export function changePasswordByAuthenticated(
  payload: ChangePasswordCustomerAuthenticated,
) {
  return usePublicApi<boolean>({
    endpoint: '/customer/password',
    method: 'PUT',
    payload,
  });
}

export function passwordRecovery(payload: PasswordRecoveryCustomer) {
  return usePublicApi<boolean>({
    endpoint: '/customer/password-recovery',
    method: 'POST',
    payload,
  });
}

// TODO validar retorno
export function changePasswordByCode(payload: ChangePasswordCustomerByCode) {
  return usePublicApi<boolean>({
    endpoint: '/customer/password-recovery',
    method: 'PUT',
    payload,
  });
}

export function createAddress(payload: UpsertCustomerAddressRequest) {
  return usePublicApi<CustomerAddressResponse>({
    method: 'POST',
    endpoint: '/customer/address',
    payload,
  });
}

export function updateAddress(
  addressId: number,
  payload: UpsertCustomerAddressRequest,
) {
  return usePublicApi<CustomerAddressResponse>({
    method: 'PUT',
    endpoint: `/customer/address/${addressId}`,
    payload,
  });
}

export function updatePrimaryAddress(addressId: number) {
  return usePublicApi<CustomerAddressResponse>({
    method: 'PUT',
    endpoint: `/customer/address/main/${addressId}`,
  });
}

export function deleteAddress(addressId: number) {
  return usePublicApi<CustomerAddressResponse>({
    method: 'DELETE',
    endpoint: `/customer/address/${addressId}`,
  });
}

export function listAddress() {
  return usePublicApi<CustomerAddressesResponse>({
    method: 'GET',
    endpoint: '/customer/address',
  });
}

export function detailOrderGroup(
  orderId: number,
  options?: Pick<ApiParams<CustomerOrderGroupFields>, 'fields'>,
) {
  return usePublicApi<CustomerOrderResponse, CustomerOrderGroupFields>({
    method: 'GET',
    endpoint: `/customer/orders/groups/${orderId}`,
    params: options,
  });
}

export function listOrderGroups(
  options?: Pick<
    ApiParams<
      CustomerOrderGroupFields,
      CustomerOrderGroupSortFields,
      CustomerOrderGroupConditionFields
    >,
    'condition' | 'fields' | 'limit' | 'offset' | 'order'
  >,
) {
  return usePublicApi<
    CustomerOrdersResponse,
    CustomerOrderGroupFields,
    CustomerOrderGroupSortFields,
    CustomerOrderGroupConditionFields
  >({
    method: 'GET',
    endpoint: '/customer/orders/groups',
    params: options,
  });
}

export function listOrderItemHistory(
  orderId: number,
  options?: Pick<
    ApiParams<
      '',
      CustomerOrderItemHistorySortFields,
      CustomerOrderItemHistoryConditionFields
    >,
    'condition' | 'fields' | 'limit' | 'offset' | 'order'
  >,
) {
  return usePublicApi<
    CustomerOrderItemHistoriesResponse,
    '',
    CustomerOrderItemHistorySortFields,
    CustomerOrderItemHistoryConditionFields
  >({
    method: 'GET',
    endpoint: `/customer/orders/${orderId}/history`,
    params: options,
  });
}

export function addNewsletter(payload: AddCustomerToNewsletterRequest) {
  return usePublicApi<AddCustomerToNewsletterResponse>({
    method: 'POST',
    endpoint: '/customer/newsletter',
    payload,
  });
}

export function deleteNewsletter() {
  return usePublicApi<CustomerOrderResponse, CustomerOrderGroupFields>({
    method: 'DELETE',
    endpoint: '/customer/newsletter',
  });
}

export function listCustomerHistory(
  options?: Pick<
    ApiParams<'', CustomerHistorySortFields, CustomerHistoryConditionFields>,
    'condition' | 'limit' | 'offset' | 'order'
  >,
) {
  return usePublicApi<
    CustomerHistoryResponse,
    '',
    CustomerHistorySortFields,
    CustomerHistoryConditionFields
  >({
    endpoint: '/customer/history',
    method: 'GET',
    params: options,
  });
}



export function detailWishlist(
  wishlistId: number,
  options?: Pick<
    ApiParams<ProductFields, '', ''>,
    'fields' | 'limit' | 'offset'
  >,
) {
  return usePublicApi<
    CustomerDetailWishlistResponse,
    ProductFields,
    '',
    ''
  >({
    endpoint: `/customer/wish-list/${wishlistId}/products`,
    method: 'GET',
    params: options,
  });
}

export function listWishlist(
  options?: Pick<
    ApiParams<'', CustomerWishlistSortFields, CustomerWishlistConditionFields>,
    'condition' | 'limit' | 'offset' | 'order'
  >,
) {
  return usePublicApi<
    CustomerListWishlistResponse,
    '',
    CustomerWishlistSortFields,
    CustomerWishlistConditionFields
  >({
    endpoint: '/customer/wish-list/',
    method: 'GET',
    params: options,
  });
}


export function addProductToWishlist(payload: AddProductToWishlistRequest) {
   return usePublicApi<true>({
    endpoint: '/customer/wish-list/product',
    method: 'POST',
    payload,
  });
}

export function removeProductToWishlist(wishlistId: number, productId: number) {
  return usePublicApi<true>({
    endpoint: `/customer/wish-list/${wishlistId}/product/${productId}`,
    method: 'DELETE'
  });
}

export function listSalesChannelByEmail(payload: { identification: string; }) {
  return usePublicApi<Array<SalesChannelByEmailResponse>>({
    method: 'POST',
    endpoint: '/customer/login/check-sales-channel',
    payload,
  });
}