import type { ApiResponse } from '~/types/ApiResponse';
import type { CuponResponse, PromocionActiva, DataCupon } from '~/types/promocion';
import type { DatosIniciales } from "~/types/Pedido";
import type { Producto } from "~/types/Producto";
import { object, string } from "yup";
import { useUserStore } from "~/store/user";
import { useClienteStore } from "~/store/cliente";
import { usePedidoStore } from "~/store/pedido";

export const usePedidoCilindro = () => {

  const { swal } = useSweetAlert();
  const userStore = useUserStore();
  const clienteStore = useClienteStore();
  const pedidoStore = usePedidoStore();

  const cliente = clienteStore.cliente;
  const clienteId = cliente?.id;
  const cilindros = ref<Producto[]>([]);
  const cuponResponse = ref<CuponResponse>()
  const promocionActiva = ref<PromocionActiva>({
    cupones: [],
    promociones: []
  });

  const tarjeta = ref<any>({
    metodo_pago: "Efectivo",
    tarjeta_nombre: null,
    tarjeta_tipo: null,
    banco: null,
    pos: null,
    autorizacion: null,
  });
  const pedidoProgramado = ref(false)
  const puntosCliente = ref(0)
  const salir = ref(false);
  // ::::::::::::::   Canjear cupón   ::::::::::::::
  const canjearCupon = async () => {
    try {
      userStore.globalLoading = true;
      const body = {
        action: 'validar_cupon',
        no_cupon: no_cupon.value,
        promocion_id: promocion_id.value
      }
      const { data, success, message } = await useApiFetch<CuponResponse>(
        "/admin/cupon",
        {
          method: "POST",
          body: body,
        },
      );
      pedidoStore.setCupon(data)
      cuponResponse.value = { data, success, message } as any
    } catch (err: any) {
      swal.fire({
        title: "Ocurrió un error inesperado",
        text: err.message || "Ocurrió un error inesperado",
        icon: "error",
      });
    } finally {
      userStore.globalLoading = false;
    }
  }
  // Cargar datos iniciales importantes para el formulario de pedidos
  const cargarDatosIniciales = async () => {
    try {
      userStore.globalLoading = true;
      const { data, success, message } = await useApiFetch<DatosIniciales>(
        "/admin/pedido",
        {
          method: "POST",
          body: {
            action: "datos_iniciales",
            cliente_id: clienteId,
          },
        },
      );

      if (success) {
        const { productos, direcciones, origenes, promociones_activas, puntos } = data as any;
        clienteStore.setDireccionesOrigenes(direcciones, origenes);
        cilindros.value = productos.map((item: Producto) => ({
          ...item,
          cantidad: 0,
          valvula_id: item.valvulas[0]?.id,
        }));
        promocionActiva.value = promociones_activas
        puntosCliente.value = puntos
      } else {
        swal.fire({
          title: "Obteniendo datos iniciales del cliente",
          text: message,
          icon: "error",
        });
      }
    } catch (err: any) {
      swal.fire({
        title: "Ocurrió un error inesperado",
        text: err.message || "Ocurrió un error inesperado",
        icon: "error"
      });
    } finally {
      userStore.globalLoading = false;
    }
  }

  // ::::::::::::::   Guardar pedido   ::::::::::::::
  const guardarPedido = async () => {
    try {
      userStore.globalLoading = true;
      const cart = pedidoStore.cart;
      //TODO: limpiar direccion al finalizar el pedido, orgigen y cupon
      const direccion = { ...clienteStore.direccion, cef: { ...clienteStore.direccion.cef } }
      const origen_id = clienteStore.origen_id
      const cupon = pedidoStore.cupon
      //::::::::::::::::: Validaciones :::::::::::::::::
      //Carrito
      if (cart.length == 0) {
        await swal.fire({
          title: "Carrito",
          text: "El carrito no puede estar vacío",
          icon: "error"
        });
        return
      }
      //Direccion
      const validarDireccion = direccion?.id ? false : true
      if (validarDireccion) {
        await swal.fire({
          title: "Datos de entrega",
          text: "Por favor, seleccionar una dirección",
          icon: "error"
        });
        return
      }
      // Origen del pedido
      const origen = origen_id ? false : true
      if (origen) {
        await swal.fire({
          title: "Datos de entrega",
          text: "Por favor, seleccionar Origen del pedido",
          icon: "error"
        });
        return
      }
      if (datosPago()?.has_error) {
        await swal.fire({
          title: "Datos de pago",
          text: datosPago()?.message,
          icon: "error"
        });
        return
      }
      //Cupon
      const promocion = cupon.promocion ? { promocion: { ...cupon.promocion } } : {}
      const cupon_canjeado = { ...cupon, ...promocion }
      const detalle = cart.map((p: Producto) => {
        const item = {
          producto_id: p.id,
          precio: p.precio,
          valvula_id: p.valvula_id,
          cantidad: p.cantidad
        }
        return item;
      });
      //Datos personales
      const datosPersonales = {
        cliente_id: cliente?.id,
        nombre_cliente: cliente?.nombre ?? '',
        apellido_cliente: cliente?.apellido ?? '',
        telefono_cliente: cliente?.celular ?? '',
        cliente_nuevo: cliente?.nuevo ?? 0,
      }
      //Metodo de pago
      const metodoPago = { ...tarjeta.value }
      const body = {
        action: "store",
        canal: "CEF",
        ...datosPersonales,
        direccion_id: direccion.id,
        direccion,
        total: pedidoStore.totalCarrito,
        detalle: detalle,
        origen_id: origen_id,
        ...metodoPago,
        cupon: cupon_canjeado,
        programado: pedidoProgramado.value,
        pedido_programado: pedidoProgramado.value
      }

      console.log('Pedido', body)
      if (cuponVacio(cupon_canjeado)) {
        delete body.cupon
      }
      const { data, success, message } = await useApiFetch<ApiResponse<any>>(
        "/admin/pedido",
        {
          method: "POST",
          body: body,
        },
      );
      if (success) {
        salir.value = true
        swal.fire({
          title: "Pedido exitoso",
          text: message,
          icon: "success"
        });
        navigateTo("/admin/clientes");
      } else {
        swal.fire({
          title: "Error en el pedido Del lado del ac",
          text: message,
          icon: "error"
        });
      }

    } catch (err: any) {
      swal.fire({
        title: "Ocurrió un error inesperado",
        text: err.message || "Ocurrió un error inesperado",
        icon: "error"
      });
    } finally {
      userStore.globalLoading = false;
    }
  }
  // ::::::::::::::   Validaciones   ::::::::::::::
  const cuponVacio = (obj: any) => {
    return obj && Object.keys(obj).length === 0 && obj.constructor === Object;
  };
  // ::::::::::::::   Datos de pago   ::::::::::::::
  function datosPago() {
    const metodo = { ...tarjeta.value }
    if (metodo.metodo_pago === 'Tarjeta') {
      const validaciones = [
        { has_error: !metodo.tarjeta_nombre, msg: 'El campo titular tarjeta no puede estar vacío' },
        { has_error: !metodo.tarjeta_tipo, msg: 'Por favor, seleccionar una tarjeta.' },
        { has_error: !metodo.banco, msg: 'Por favor, seleccionar un banco.' },
        { has_error: !metodo.pos, msg: 'Por favor, seleccionar un pos.' },
        { has_error: !metodo.autorizacion, msg: 'El campo autorización tarjeta no puede estar vacío' }
      ];
      const error = validaciones.find(v => v.has_error);
      if (error) {
        return { has_error: true, message: error.msg };
      }
    } else {
      tarjeta.value.tarjeta_nombre = null
      tarjeta.value.tarjeta_tipo = null
      tarjeta.value.banco = null
      tarjeta.value.pos = null
      tarjeta.value.autorizacion = null
    }
    return {
      has_error: false,
      message: ''
    }
  }
  // ::::::::::::::   Canjear cupón   ::::::::::::::
  const schema = object({
    promocion_id: string().required("Por favor, seleccionar una promoción."),
    no_cupon: string().required("El cupón inicial no puede estar vacío"),
  });

  const { setValues, submit: canjear_cupon, errors: cupon_errors, defineField, resetForm: reset_cupon_form } = useFormValidation(
    schema,
    canjearCupon,
  );
  const [promocion_id] = defineField("promocion_id");
  const [no_cupon] = defineField("no_cupon");

  onUnmounted(() => {
    //Limpiar el store
    pedidoStore.cart = []
    pedidoStore.cupon = {}
    clienteStore.direccion = {}
    clienteStore.origen_id = null
  })

  onBeforeRouteLeave(async () => {
    if (salir.value) {
      return true
    }
    const result = await swal.fire({
      title: '¿Desea salir del pedido?',
      text: 'Se perderán todos los datos del pedido.',
      icon: 'question',
      showCancelButton: true,
    })
    if (!result.isConfirmed) {
      return false
    }
    return true
  })
  return {
    cargarDatosIniciales,
    canjear_cupon,
    guardarPedido,
    cupon_errors,
    cilindros,
    promocion_id,
    no_cupon,
    promocionActiva,
    cuponResponse,
    tarjeta,
    pedidoProgramado,
    puntosCliente
  }
}