package com.imprimelibros.erp.pedidos;

import java.time.Instant;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.springframework.context.MessageSource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.imprimelibros.erp.cart.Cart;
import com.imprimelibros.erp.cart.CartDireccion;
import com.imprimelibros.erp.cart.CartItem;
import com.imprimelibros.erp.cart.CartService;
import com.imprimelibros.erp.common.Utils;
import com.imprimelibros.erp.direcciones.Direccion;
import com.imprimelibros.erp.presupuesto.PresupuestoRepository;
import com.imprimelibros.erp.presupuesto.dto.Presupuesto;
import com.imprimelibros.erp.presupuesto.service.PresupuestoService;
import com.imprimelibros.erp.users.UserService;
import com.imprimelibros.erp.direcciones.DireccionService;
import com.imprimelibros.erp.externalApi.skApiClient;
import com.imprimelibros.erp.facturacion.FacturaDireccion;
import com.imprimelibros.erp.facturacion.dto.DireccionFacturacionDto;
import com.imprimelibros.erp.pedidos.PedidoLinea.Estado;

@Service
public class PedidoService {

    private final PedidoRepository pedidoRepository;
    private final PedidoLineaRepository pedidoLineaRepository;
    private final PresupuestoRepository presupuestoRepository;
    private final PedidoDireccionRepository pedidoDireccionRepository;
    private final DireccionService direccionService;
    private final UserService userService;
    private final PresupuestoService presupuestoService;
    private final CartService cartService;
    private final skApiClient skApiClient;
    private final PresupuestoRepository presupuestoRepo;
    private final MessageSource messageSource;

    public PedidoService(PedidoRepository pedidoRepository, PedidoLineaRepository pedidoLineaRepository,
            PresupuestoRepository presupuestoRepository, PedidoDireccionRepository pedidoDireccionRepository,
            DireccionService direccionService, UserService userService, PresupuestoService presupuestoService,
            CartService cartService, skApiClient skApiClient, PresupuestoRepository presupuestoRepo,
            MessageSource messageSource) {
        this.pedidoRepository = pedidoRepository;
        this.pedidoLineaRepository = pedidoLineaRepository;
        this.presupuestoRepository = presupuestoRepository;
        this.pedidoDireccionRepository = pedidoDireccionRepository;
        this.direccionService = direccionService;
        this.userService = userService;
        this.presupuestoService = presupuestoService;
        this.cartService = cartService;
        this.skApiClient = skApiClient;
        this.presupuestoRepo = presupuestoRepo;
        this.messageSource = messageSource;
    }

    public Pedido getPedidoById(Long pedidoId) {
        return pedidoRepository.findById(pedidoId).orElse(null);
    }

    public PedidoDireccion getPedidoDireccionFacturacionByPedidoId(Long pedidoId) {
        return pedidoDireccionRepository.findByPedidoIdAndFacturacionTrue(pedidoId);
    }

    @Transactional
    public Pedido crearPedido(
            Long cartId,
            Long direccionFacturacionId,
            String proveedor,
            String proveedorRef) {

        Pedido pedido = new Pedido();

        Cart cart = cartService.getCartById(cartId);
        Map<String, Object> cartSummaryRaw = cartService.getCartSummaryRaw(cart, Locale.getDefault());

        // Datos económicos (ojo con las claves, son las del summaryRaw)
        pedido.setBase((Double) cartSummaryRaw.getOrDefault("base", 0.0d));
        pedido.setEnvio((Double) cartSummaryRaw.getOrDefault("shipment", 0.0d));
        pedido.setIva4((Double) cartSummaryRaw.getOrDefault("iva4", 0.0d));
        pedido.setIva21((Double) cartSummaryRaw.getOrDefault("iva21", 0.0d));
        pedido.setDescuento((Double) cartSummaryRaw.getOrDefault("descuento", 0.0d));
        pedido.setTotal((Double) cartSummaryRaw.getOrDefault("total", 0.0d));

        // Proveedor
        if (proveedor != null && proveedorRef != null) {
            pedido.setProveedor(proveedor);
            pedido.setProveedorRef(proveedorRef);
        }

        // Auditoría mínima
        /*
         * Long userId = cart.getUserId();
         * pedido.setCreatedBy(userService.findById(userId));
         * pedido.setUpdatedBy(userService.findById(userId));
         */
        // Se obtiene el usuario del primer presupuesto del carrito
        Long userId = null;
        List<CartItem> cartItems = cart.getItems();
        if (!cartItems.isEmpty()) {
            Presupuesto firstPresupuesto = cartItems.get(0).getPresupuesto();
            if (firstPresupuesto != null) {
                userId = firstPresupuesto.getUser().getId();
            }
        }
        if (userId == null) {
            userId = cart.getUserId();
        }
        pedido.setCreatedBy(userService.findById(userId));
        pedido.setUpdatedBy(userService.findById(userId));
        pedido.setCreatedAt(Instant.now());
        pedido.setDeleted(false);
        pedido.setUpdatedAt(Instant.now());

        // Guardamos el pedido
        Pedido pedidoGuardado = pedidoRepository.save(pedido);
        pedidoGuardado.setCreatedBy(userService.findById(userId));
        pedidoGuardado.setUpdatedBy(userService.findById(userId));
        pedidoRepository.save(pedidoGuardado);

        List<CartItem> items = cart.getItems();

        for (Integer i = 0; i < items.size(); i++) {
            CartItem item = items.get(i);
            Presupuesto pCart = item.getPresupuesto();

            // Asegurarnos de trabajar con la entidad gestionada por JPA
            Presupuesto p = presupuestoRepository.findById(pCart.getId())
                    .orElseThrow(() -> new IllegalStateException("Presupuesto no encontrado: " + pCart.getId()));
            p.setEstado(Presupuesto.Estado.aceptado);
            presupuestoRepository.save(p);

            PedidoLinea linea = new PedidoLinea();
            linea.setPedido(pedidoGuardado);
            linea.setPresupuesto(p);
            linea.setCreatedBy(userId);
            linea.setCreatedAt(LocalDateTime.now());
            linea.setEstado(PedidoLinea.Estado.pendiente_pago);
            linea.setEstadoManual(false);
            pedidoLineaRepository.save(linea);

            // Guardar las direcciones asociadas a la línea del pedido
            Map<String, Object> direcciones_presupuesto = this.getDireccionesPresupuesto(cart, p);
            saveDireccionesPedidoLinea(direcciones_presupuesto, pedidoGuardado, linea, direccionFacturacionId);

        }

        return pedidoGuardado;
    }

    public Boolean markPedidoAsProcesingPayment(Long pedidoId) {
        Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
        if (pedido == null) {
            return false;
        }
        List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
        for (PedidoLinea linea : lineas) {
            linea.setEstado(PedidoLinea.Estado.procesando_pago);
            pedidoLineaRepository.save(linea);
        }

        return true;
    }

    public Boolean markPedidoAsPaymentDenied(Long pedidoId) {
        Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
        if (pedido == null) {
            return false;
        }
        List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
        for (PedidoLinea linea : lineas) {
            linea.setEstado(PedidoLinea.Estado.denegado_pago);
            pedidoLineaRepository.save(linea);
        }

        return true;
    }

    public Pedido findById(Long pedidoId) {
        return pedidoRepository.findById(pedidoId).orElse(null);
    }

    @Transactional
    public Boolean upsertDireccionFacturacion(Long pedidoId, DireccionFacturacionDto direccionData) {

        try {
            Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
            if (pedido != null) {

                PedidoDireccion direccionPedido = pedidoDireccionRepository.findByPedidoIdAndFacturacionTrue(pedidoId);

                if (direccionPedido == null) {
                    // crear
                    direccionPedido = direccionData.toPedidoDireccion();
                    direccionPedido.setPedido(pedido);

                } else {
                    // actualizar en la existente (NO crees una nueva, para conservar ID)
                    direccionData.applyTo(direccionPedido); // si implementas applyTo()
                    direccionPedido.setFacturacion(true); // por si acaso
                }

                pedidoDireccionRepository.save(direccionPedido);
            }

            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /** Lista de los items del pedido preparados para la vista */
    @Transactional
    public List<Map<String, Object>> getLineas(Long pedidoId, Locale locale) {
        Pedido p = pedidoRepository.findById(pedidoId).orElse(null);
        if (p == null) {
            return new ArrayList<>();
        }

        List<Map<String, Object>> resultados = new ArrayList<>();
        List<PedidoLinea> items = pedidoLineaRepository.findByPedidoIdOrderByIdAsc(p.getId());
        for (PedidoLinea item : items) {

            Presupuesto presupuesto = item.getPresupuesto();
            Map<String, Object> elemento = presupuestoService.getPresupuestoInfoForCard(presupuesto, locale);
            elemento.put("estado", item.getEstado());
            elemento.put("fechaEntrega",
                    item.getFechaEntrega() != null ? Utils.formatDate(item.getFechaEntrega(), locale) : "");
            elemento.put("lineaId", item.getId());
            resultados.add(elemento);
        }
        return resultados;
    }

    public PedidoDireccion getDireccionFacturacionPedido(Long pedidoId) {
        return pedidoDireccionRepository.findByPedidoIdAndFacturacionTrue(pedidoId);
    }

    public List<PedidoDireccion> getDireccionesEntregaPedidoLinea(Long pedidoLineaId) {
        return pedidoDireccionRepository.findByPedidoLinea_Id(pedidoLineaId);
    }

    public Boolean setOrderAsPaid(Long pedidoId) {
        Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
        if (pedido == null) {
            return false;
        }
        List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
        List<Map<String, Object>> referenciasProveedor = new ArrayList<>();
        Integer total = lineas.size();
        Integer counter = 1;
        for (PedidoLinea linea : lineas) {
            if (linea.getEstado() == Estado.pendiente_pago
                    || linea.getEstado() == Estado.denegado_pago) {

                Presupuesto presupuesto = linea.getPresupuesto();
                linea.setEstado(getEstadoInicial(presupuesto));
                pedidoLineaRepository.save(linea);

                // Save presupuesto in SK
                Map<String, Object> result = savePresupuestoSK(linea.getId(), presupuesto, counter, total);
                if (result == null) {
                    return false;
                }
                referenciasProveedor.add(result);
                counter++;
            }
        }

        if (referenciasProveedor.isEmpty()) {
            return false;
        }

        // Save pedido in SK
        ArrayList<Long> presupuestoSkIds = new ArrayList<>();
        for (Map<String, Object> presData : referenciasProveedor) {
            Long presId = ((Number) presData.get("id")).longValue();
            presupuestoSkIds.add(presId);
        }

        Map<String, Object> ids = new HashMap<>();
        ids.put("presupuesto_ids", presupuestoSkIds);
        Long skPedidoId = skApiClient.crearPedido(ids);
        if (skPedidoId == null) {
            System.out.println("No se pudo crear el pedido en SK.");
            return false;
        }
        pedido.setProveedor("Safekat");
        pedido.setProveedorRef(skPedidoId.toString());
        pedidoRepository.save(pedido);
        return true;
    }

    public Map<String, Object> actualizarEstado(Long pedidoLineaId, Locale locale) {

        PedidoLinea pedidoLinea = pedidoLineaRepository.findById(pedidoLineaId).orElse(null);
        if (pedidoLinea == null) {
            return Map.of(
                    "success", false,
                    "message", messageSource.getMessage("pedido.errors.linea-not-found", null, locale));
        }

        PedidoLinea.Estado estadoOld = pedidoLinea.getEstado();
        if (estadoOld == null) {
            return Map.of(
                    "success", false,
                    "message", messageSource.getMessage("pedido.errors.cannot-update", null, locale));
        }

        // Rango: >= haciendo_ferro y < enviado
        if (estadoOld.getPriority() < PedidoLinea.Estado.haciendo_ferro.getPriority()
                || estadoOld.getPriority() >= PedidoLinea.Estado.enviado.getPriority()) {
            return Map.of(
                    "success", false,
                    "message", messageSource.getMessage("pedido.errors.cannot-update", null, locale));
        }

        var presupuesto = pedidoLinea.getPresupuesto();
        if (presupuesto == null || presupuesto.getProveedorRef2() == null) {
            return Map.of(
                    "success", false,
                    "message", messageSource.getMessage("pedido.errors.update-server-error", null, locale));
        }

        Long refExterna;
        try {
            refExterna = Long.valueOf(presupuesto.getProveedorRef2().toString());
        } catch (Exception ex) {
            return Map.of(
                    "success", false,
                    "message", messageSource.getMessage("pedido.errors.update-server-error", null, locale));
        }

        Map<String, Object> result = skApiClient.checkPedidoEstado(refExterna, locale);

        if (result == null || result.get("estado") == null) {
            return Map.of(
                    "success", false,
                    "message", messageSource.getMessage("pedido.errors.update-server-error", null, locale));
        }

        String estadoStr = String.valueOf(result.get("estado"));

        PedidoLinea.Estado estadoSk;
        try {
            // si la API devuelve minúsculas tipo "produccion", esto funciona
            estadoSk = PedidoLinea.Estado.valueOf(estadoStr.trim().toLowerCase());
        } catch (Exception ex) {
            return Map.of(
                    "success", false,
                    "message", messageSource.getMessage("pedido.errors.update-server-error", null, locale));
        }

        if (estadoOld == estadoSk) {
            return Map.of(
                    "success", true,
                    "state", messageSource.getMessage("pedido.estado." + estadoSk.name(), null, locale),
                    "stateKey", estadoSk.name(),
                    "message", messageSource.getMessage("pedido.success.same-estado", null, locale));
        }

        pedidoLinea.setEstado(estadoSk);
        pedidoLineaRepository.save(pedidoLinea);

        return Map.of(
                "success", true,
                "state", messageSource.getMessage("pedido.estado." + estadoSk.name(), null, locale),
                "stateKey", estadoSk.name(),
                "message", messageSource.getMessage("pedido.success.estado-actualizado", null, locale));
    }

    public Boolean markPedidoAsMaquetacionDone(Long pedidoId) {
        Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
        if (pedido == null) {
            return false;
        }
        List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
        for (PedidoLinea linea : lineas) {
            if (linea.getEstado() == Estado.maquetacion) {
                linea.setEstado(Estado.haciendo_ferro);
                pedidoLineaRepository.save(linea);
            }
        }

        return true;
    }

    public Map<String, Object> getFilesType(Long pedidoLineaId, Locale locale) {
        PedidoLinea pedidoLinea = pedidoLineaRepository.findById(pedidoLineaId).orElse(null);
        if (pedidoLinea == null) {
            return Map.of("success", false, "message", "Línea de pedido no encontrada.");
        }
        Map<String, Object> files = skApiClient.getFilesTypes(
                Long.valueOf(pedidoLinea.getPresupuesto().getProveedorRef2().toString()), locale);
        return files;
    }

    public byte[] getFerroFileContent(Long pedidoLineaId, Locale locale) {
        return downloadFile(pedidoLineaId, "ferro", locale);
    }

    public byte[] getCubiertaFileContent(Long pedidoLineaId, Locale locale) {
        return downloadFile(pedidoLineaId, "cubierta", locale);
    }

    public byte[] getTapaFileContent(Long pedidoLineaId, Locale locale) {
        return downloadFile(pedidoLineaId, "tapa", locale);
    }

    public Boolean aceptarFerro(Long pedidoLineaId, Locale locale) {
        PedidoLinea pedidoLinea = pedidoLineaRepository.findById(pedidoLineaId).orElse(null);
        if (pedidoLinea == null) {
            return false;
        }
        if (pedidoLinea.getEstado() != PedidoLinea.Estado.esperando_aceptacion_ferro) {
            return false;
        }
        Boolean result = skApiClient.aceptarFerro(
                Long.valueOf(pedidoLinea.getPresupuesto().getProveedorRef2().toString()), locale);
        if (!result) {
            return false;
        }
        pedidoLinea.setEstado(PedidoLinea.Estado.produccion);
        pedidoLineaRepository.save(pedidoLinea);
        return true;
    }

    public Boolean cancelarPedido(Long pedidoId) {

        Pedido pedido = pedidoRepository.findById(pedidoId).orElse(null);
        if (pedido == null) {
            return false;
        }
        Boolean result = skApiClient.cancelarPedido(Long.valueOf(pedido.getProveedorRef()));
        if (!result) {
            return false;
        }
        List<PedidoLinea> lineas = pedidoLineaRepository.findByPedidoId(pedidoId);
        for (PedidoLinea linea : lineas) {
            if (linea.getEstado() != PedidoLinea.Estado.terminado && linea.getEstado() != PedidoLinea.Estado.enviado) {
                linea.setEstado(PedidoLinea.Estado.cancelado);
                pedidoLineaRepository.save(linea);
            }
        }

        return true;
    }

    /***************************
     * MÉTODOS PRIVADOS
     ***************************/

    private byte[] downloadFile(Long pedidoLineaId, String fileType, Locale locale) {
        PedidoLinea pedidoLinea = pedidoLineaRepository.findById(pedidoLineaId).orElse(null);
        if (pedidoLinea == null) {
            return null;
        }
        byte[] fileData = skApiClient.downloadFile(
                Long.valueOf(pedidoLinea.getPresupuesto().getProveedorRef2().toString()),
                fileType,
                locale);
        return fileData;
    }

    @Transactional
    private Map<String, Object> savePresupuestoSK(Long pedidoLineaId, Presupuesto presupuesto, Integer counter,
            Integer total) {

        Map<String, Object> data_to_send = presupuestoService.toSkApiRequest(presupuesto, true);
        data_to_send.put("createPedido", 0);

        // Recuperar el mapa anidado datosCabecera
        @SuppressWarnings("unchecked")
        Map<String, Object> datosCabecera = (Map<String, Object>) data_to_send.get("datosCabecera");
        if (datosCabecera != null) {
            Object tituloOriginal = datosCabecera.get("titulo");
            datosCabecera.put(
                    "titulo",
                    "[" + (counter) + "/" + total + "] " + (tituloOriginal != null ? tituloOriginal : ""));
        }

        List<PedidoDireccion> direccionesPedidoLinea = pedidoDireccionRepository
                .findByPedidoLineaId(pedidoLineaId);
        List<Map<String, Object>> direccionesPresupuesto = new ArrayList<>();
        List<Map<String, Object>> direccionEjemplarPrueba = new ArrayList<>();

        for (PedidoDireccion pd : direccionesPedidoLinea) {
            if (pd.isEjemplarPrueba()) {
                direccionEjemplarPrueba.add(
                        pd.toSkMap(presupuesto.getPeso()));
            } else {
                direccionesPresupuesto.add(
                        pd.toSkMap(presupuesto.getPeso() * pd.getUnidades()));
            }

        }
        if (presupuesto.getServiciosJson() != null && presupuesto.getServiciosJson().contains("deposito-legal")) {
            direccionesPresupuesto.add(
                    PedidoDireccion.toSkMapDepositoLegal());
        }
        data_to_send.put("direcciones", direccionesPresupuesto);
        if (direccionEjemplarPrueba.size() > 0)
            data_to_send.put("direccionesFP1", direccionEjemplarPrueba.get(0));
        else {
            data_to_send.put("direccionesFP1", new ArrayList<>());
        }

        Map<String, Object> result = skApiClient.savePresupuesto(data_to_send);

        if (result.containsKey("error")) {
            System.out.println("Error al guardar presupuesto en SK");
            System.out.println("-------------------------");
            System.out.println(result.get("error"));
            // decide si seguir con otros items o abortar:
            // continue; o bien throw ...
            return null;
        }

        Object dataObj = result.get("data");
        if (!(dataObj instanceof Map<?, ?> dataRaw)) {
            System.out.println("Formato inesperado de 'data' en savePresupuesto: " + result);
            return null;
        }

        @SuppressWarnings("unchecked")
        Map<String, Object> dataMap = (Map<String, Object>) dataRaw;
        Long presId = ((Number) dataMap.get("id")).longValue();
        String skin = ((String) dataMap.get("iskn")).toString();
        presupuesto.setProveedor("Safekat");
        presupuesto.setProveedorRef1(skin);
        presupuesto.setProveedorRef2(presId);
        presupuesto.setEstado(Presupuesto.Estado.aceptado);
        presupuestoRepo.save(presupuesto);

        return dataMap;
    }

    // Obtener las direcciones de envío asociadas a un presupuesto en el carrito
    private Map<String, Object> getDireccionesPresupuesto(Cart cart, Presupuesto presupuesto) {

        List<Map<String, Object>> direccionesPresupuesto = new ArrayList<>();
        List<Map<String, Object>> direccionesPrueba = new ArrayList<>();
        if (cart.getOnlyOneShipment()) {
            List<CartDireccion> direcciones = cart.getDirecciones().stream().limit(1).toList();
            if (!direcciones.isEmpty()) {
                if (presupuesto.getServiciosJson() != null
                        && presupuesto.getServiciosJson().contains("deposito-legal")) {
                    direccionesPresupuesto.add(direcciones.get(0).toSkMap(
                            presupuesto.getSelectedTirada(),
                            presupuesto.getPeso(),
                            direcciones.get(0).getIsPalets(),
                            false));

                    direccionesPresupuesto.add(direcciones.get(0).toSkMapDepositoLegal());
                } else {
                    direccionesPresupuesto.add(direcciones.get(0).toSkMap(
                            presupuesto.getSelectedTirada(),
                            presupuesto.getPeso(),
                            direcciones.get(0).getIsPalets(),
                            false));
                }
                if (presupuesto.getServiciosJson() != null
                        && presupuesto.getServiciosJson().contains("ejemplar-prueba")) {
                    direccionesPrueba.add(direcciones.get(0).toSkMap(
                            1,
                            presupuesto.getPeso(),
                            false,
                            true));
                }

                Map<String, Object> direccionesRet = new HashMap<>();
                direccionesRet.put("direcciones", direccionesPresupuesto);
                if (!direccionesPrueba.isEmpty())
                    direccionesRet.put("direccionesFP1", direccionesPrueba.get(0));
                else {
                    direccionesRet.put("direccionesFP1", new ArrayList<>());
                }
                return direccionesRet;
            }
        } else {
            List<CartDireccion> direcciones = cart.getDirecciones().stream()
                    .filter(d -> d.getPresupuesto() != null && d.getPresupuesto().getId().equals(presupuesto.getId()))
                    .toList();

            for (CartDireccion cd : direcciones) {

                // direccion de ejemplar de prueba
                if (cd.getPresupuesto() == null || !cd.getPresupuesto().getId().equals(presupuesto.getId())) {
                    continue;
                }
                if (cd.getUnidades() == null || cd.getUnidades() <= 0) {
                    direccionesPrueba.add(cd.toSkMap(
                            1,
                            presupuesto.getPeso(),
                            false,
                            true));
                } else {
                    direccionesPresupuesto.add(cd.toSkMap(
                            cd.getUnidades(),
                            presupuesto.getPeso(),
                            cd.getIsPalets(),
                            false));
                }
            }
            if (presupuesto.getServiciosJson() != null
                    && presupuesto.getServiciosJson().contains("deposito-legal")) {
                CartDireccion cd = new CartDireccion();
                direccionesPresupuesto.add(cd.toSkMapDepositoLegal());
            }
        }
        Map<String, Object> direccionesRet = new HashMap<>();
        direccionesRet.put("direcciones", direccionesPresupuesto);
        if (!direccionesPrueba.isEmpty())
            direccionesRet.put("direccionesFP1", direccionesPrueba.get(0));
        else {
            direccionesRet.put("direccionesFP1", new ArrayList<>());
        }
        return direccionesRet;
    }

    @Transactional
    private void saveDireccionesPedidoLinea(
            Map<String, Object> direcciones,
            Pedido pedido,
            PedidoLinea linea, Long direccionFacturacionId) {

        String email = pedido.getCreatedBy().getUserName();

        // direccion prueba
        if (direcciones.containsKey("direccionesFP1")) {

            try {
                @SuppressWarnings("unchecked")
                Map<String, Object> fp1 = (Map<String, Object>) direcciones.get("direccionesFP1");
                @SuppressWarnings("unchecked")
                PedidoDireccion direccion = saveDireccion(
                        email,
                        false,
                        (HashMap<String, Object>) fp1.get("direccion"),
                        pedido,
                        linea,
                        true,
                        false);
                pedidoDireccionRepository.save(direccion);
            } catch (Exception e) {
                // Viene vacio
            }
        }
        if (direcciones.containsKey("direcciones")) {
            List<?> dirs = (List<?>) direcciones.get("direcciones");
            for (Object dir : dirs) {
                @SuppressWarnings("unchecked")
                HashMap<String, Object> direccionEnvio = (HashMap<String, Object>) ((HashMap<String, Object>) dir)
                        .get("direccion");
                if (direccionEnvio.get("cantidad") != null && (Integer) direccionEnvio.get("cantidad") == 4
                        && direccionEnvio.get("att").toString().contains("Depósito Legal")) {
                    continue; // Saltar la dirección de depósito legal
                }
                @SuppressWarnings("unchecked")
                PedidoDireccion direccion = saveDireccion(
                        email,
                        ((Number) ((HashMap<String, Object>) dir)
                                .getOrDefault("entregaPalets", 0))
                                .intValue() == 1,
                        (HashMap<String, Object>) ((HashMap<String, Object>) dir).get("direccion"),
                        pedido,
                        linea, false,
                        false);
                pedidoDireccionRepository.save(direccion);
            }
        }
        if (direccionFacturacionId != null) {
            Direccion dirFact = direccionService.findById(direccionFacturacionId).orElse(null);
            if (dirFact != null) {
                HashMap<String, Object> dirFactMap = new HashMap<>();
                dirFactMap.put("att", dirFact.getAtt());
                dirFactMap.put("direccion", dirFact.getDireccion());
                dirFactMap.put("cp", dirFact.getCp());
                dirFactMap.put("municipio", dirFact.getCiudad());
                dirFactMap.put("provincia", dirFact.getProvincia());
                dirFactMap.put("pais_code3", dirFact.getPaisCode3());
                dirFactMap.put("telefono", dirFact.getTelefono());
                dirFactMap.put("instrucciones", dirFact.getInstrucciones());
                dirFactMap.put("razon_social", dirFact.getRazonSocial());
                dirFactMap.put("tipo_identificacion_fiscal", dirFact.getTipoIdentificacionFiscal().name());
                dirFactMap.put("identificacion_fiscal", dirFact.getIdentificacionFiscal());

                PedidoDireccion direccion = saveDireccion(
                        email,
                        false,
                        dirFactMap,
                        pedido,
                        linea,
                        false,
                        true);
                pedidoDireccionRepository.save(direccion);
            }
        }
    }

    private PedidoDireccion saveDireccion(
            String email,
            Boolean palets,
            HashMap<String, Object> dir,
            Pedido pedido,
            PedidoLinea linea,
            Boolean isEjemplarPrueba,
            Boolean isFacturacion) {

        PedidoDireccion direccion = new PedidoDireccion();
        direccion.setEmail(email);
        direccion.setPalets(isEjemplarPrueba || isFacturacion ? false : palets);
        direccion.setPedidoLinea(isFacturacion ? null : linea);
        if (isFacturacion) {
            direccion.setUnidades(null);
            direccion.setFacturacion(true);
            direccion.setPedido(pedido);

        } else {
            if (isEjemplarPrueba) {
                direccion.setUnidades(1);
                direccion.setEjemplarPrueba(true);
            } else {
                direccion.setUnidades((Integer) dir.getOrDefault("cantidad", 1));
                direccion.setEjemplarPrueba(false);
            }
            direccion.setFacturacion(false);
        }

        direccion.setAtt((String) dir.getOrDefault("att", ""));
        direccion.setDireccion((String) dir.getOrDefault("direccion", ""));
        direccion.setCp((Integer) dir.getOrDefault("cp", 0));
        direccion.setCiudad((String) dir.getOrDefault("municipio", ""));
        direccion.setProvincia((String) dir.getOrDefault("provincia", ""));
        direccion.setPaisCode3((String) dir.getOrDefault("pais_code3", "esp"));
        direccion.setTelefono((String) dir.getOrDefault("telefono", ""));
        direccion.setInstrucciones((String) dir.getOrDefault("instrucciones", ""));
        direccion.setRazonSocial((String) dir.getOrDefault("razon_social", ""));
        direccion.setTipoIdentificacionFiscal(Direccion.TipoIdentificacionFiscal
                .valueOf((String) dir.getOrDefault("tipo_identificacion_fiscal",
                        Direccion.TipoIdentificacionFiscal.DNI.name())));
        direccion.setIdentificacionFiscal((String) dir.getOrDefault("identificacion_fiscal", ""));

        return direccion;

    }

    private Estado getEstadoInicial(Presupuesto p) {

        if (presupuestoService.hasMaquetacion(p)) {
            return Estado.maquetacion;
        } else {
            return Estado.haciendo_ferro;
        }
    }

}