<?php
session_start();
$host = 'localhost';
$database = 'C:\Program Files (x86)\Common Files\Aspel\Sistemas Aspel\SAE7.00\Ejemplos\Ejemplos.fdb';
$username = 'SYSDBA';
$password = 'masterkey';
setlocale(LC_MONETARY, 'es_MX');

if ($_SERVER["REQUEST_METHOD"] == "POST") {
    try {
        $dbh = new PDO("firebird:host=$host;dbname=$database;charset=UTF8", $username, $password);
        $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

        // Da el número de documento en FOLIOSC01 de 
        $folioCompleto = $_POST['cveDoc'];
        $serie = preg_replace('/\d+/', '', $folioCompleto);
        $numero = (int) filter_var($folioCompleto, FILTER_SANITIZE_NUMBER_INT);
        $cveDoc = $_POST['cveDoc'];
        // Actualizar el número de documento en FOLIOSC01 con fecha sin hora
        $sql_update = "UPDATE FOLIOSC01 SET ULT_DOC = :new_number, FECH_ULT_DOC = CURRENT_DATE WHERE TIP_DOC = 'c' AND SERIE = :serie";
        $stmt_update = $dbh->prepare($sql_update);
        $stmt_update->execute([':new_number' => $numero, ':serie' => $serie]);

        // Obtiene el proveedor del documento
        $proveedor = $_POST['proveedor'];
        // Obtiene el esquema de el formulario
        $esquema2 = $_POST['esquema2'] ?? '';
        // Fecha de elaboracion COMPC01
        $fechaElaboracion = DateTime::createFromFormat('U.u', microtime(true))->format('Y-m-d H:i:s.v');
        $fechaPag = $_POST['fechapag'] ?? null;

        $tipomoneda = $_POST['moneda'];

        $numpagos = $_POST['pago_de'];

        $descuentofinal = $_POST['descuentofinal'];

        $fechaDoc = $_POST['fechaDoc'] ?? null;

        // Obtener folios siguiente
        $stmtFol = $dbh->query("SELECT FOLIO FROM COMPC01");
        $folios = $stmtFol->fetchAll(PDO::FETCH_COLUMN);
        $numeric_folios = [];
        foreach ($folios as $folio) {
            $folio_limpia = preg_replace('/[^0-9]/', '', $folio);
            if (is_numeric($folio_limpia)) {
                $numeric_folios[] = intval($folio_limpia);
            }
        }
        $last_folio = !empty($numeric_folios) ? max($numeric_folios) : 0;
        $new_folio = $last_folio + 1;

        // Ver la cantidad total de los productos General
        $canTot = 0;
        foreach ($_POST['productos'] as $producto) {
            $canTot += $producto['subtotal_partida'];
        }

        // Obtener campos libres general
        $query_campos_libres = "SELECT CAMPO FROM PARAM_CAMPOSLIBRES01 WHERE IDTABLA = 'COMPC_CLIB'";
        $stmt_campos = $dbh->prepare($query_campos_libres);
        $stmt_campos->execute();
        $campos_libres = [];
        while ($row = $stmt_campos->fetch(PDO::FETCH_ASSOC)) {
            $campo = $row['CAMPO'];
            $campos_libres[$campo] = $_POST['campo_libre_' . htmlspecialchars($campo)] ?? null;
        }

        // OBS_DOC01 En general
        $observacion = $_POST['observaciones_hidden'];
        // Obtener la observación general y las observaciones de los productos
        $stmtObs = $dbh->query("SELECT MAX(CVE_OBS) AS LAST_OBS FROM OBS_DOCC01");
        $lastObs = $stmtObs->fetch(PDO::FETCH_ASSOC)['LAST_OBS'] ?? 0;
        $newObs = $lastObs + 1;
        $sqlObs = "INSERT INTO OBS_DOCC01 (CVE_OBS, STR_OBS) VALUES (:cve_obs, :str_obs)";
        $stmtObsInsert = $dbh->prepare($sqlObs);
        $cveObs = $cveObs ?? 0;
        // Insertar las observaciones generales (si existen)
        if (!empty($_POST['observaciones_hidden'])) {
            $stmtObsInsert->execute([
                ':cve_obs' => $newObs,
                ':str_obs' => $_POST['observaciones_hidden']
            ]);
            $cveObs = $newObs;
            $newObs++; // Incrementar para la siguiente observación
        }


        // Insertar documento principal
        $sql = "INSERT INTO COMPC01 (
                TIP_DOC, CVE_DOC, FECHA_DOC, FECHA_REC,
                CVE_CLPV, OBS_COND, SU_REFER,
                TOT_IND,
                NUM_ALMA, NUM_MONED, TIPCAMB, NUM_PAGOS,
                CAN_TOT,
                IMP_TOT1, IMP_TOT2, IMP_TOT3, IMP_TOT4,
                STATUS, FECHAELAB, SERIE, FOLIO, CTLPOL, ESCFD, CONTADO, BLOQ, FECHA_PAG,
                DES_FIN, CVE_OBS, ACT_CXP, ACT_COI, ENLAZADO, TIP_DOC_E,
                DES_FIN_PORC, DES_TOT_PORC
            ) VALUES (
                'c', :cveDoc, :fechaDoc, :fechaRec,
                :proveedor, :entreg_a, :refproveedor,
                :gastosind,
                :almacen, :moneda, :tcambio, :pago_de,
                :canTot,
                :ieps, :ret_isr, :ret_iva, :iva,
                'O', :fechaElaboracion, :serie, :folio, 0, 'N', 'N', 'N', :fechaPag,
                '0', :cveObs, 'S', 'N', 'O', 'O',
                :descuentofinal, :descuento
            )";
        $stmt = $dbh->prepare($sql);
        $stmt->bindParam(':cveDoc', $cveDoc);
        $stmt->bindParam(':fechaDoc', $fechaDoc);
        $stmt->bindParam(':fechaRec', $_POST['fechaRec']);
        $stmt->bindParam(':proveedor', $proveedor);
        $stmt->bindParam(':entreg_a', $_POST['entreg_a']);
        $stmt->bindParam(':refproveedor', $_POST['refproveedor']);
        $stmt->bindParam(':gastosind', $_POST['gastosind']);
        $stmt->bindParam(':almacen', $_POST['almacen']);
        $stmt->bindParam(':moneda', $tipomoneda);
        $stmt->bindParam(':tcambio', $_POST['tcambio']);
        $stmt->bindParam(':pago_de', $numpagos);
        $stmt->bindParam(':ieps', $_POST['ieps']);
        $stmt->bindParam(':ret_isr', $_POST['ret_isr']);
        $stmt->bindParam(':ret_iva', $_POST['ret_iva']);
        $stmt->bindParam(':iva', $_POST['iva']);
        $stmt->bindParam(':fechaElaboracion', $fechaElaboracion);
        $stmt->bindParam(':folio', $new_folio);
        $stmt->bindParam(':serie', $serie);
        $stmt->bindParam(':fechaPag', $fechaPag);
        $stmt->bindParam(':canTot', $canTot);
        $stmt->bindParam('descuentofinal', $_POST['descuentofinal']);
        $stmt->bindParam(':descuento', $_POST['descuento']);
        $stmt->bindParam(':cveObs', $cveObs);
        $stmt->execute();

        if (!empty($campos_libres)) {

            $campos_nombres = implode(", ", array_keys($campos_libres));
            $campos_placeholders = implode(", ", array_map(fn($c) => ":$c", array_keys($campos_libres)));

            $sql_clib = "INSERT INTO COMPC_CLIB01 (CLAVE_DOC, $campos_nombres) VALUES (:clave, $campos_placeholders)";
            $stmt_clib = $dbh->prepare($sql_clib);
            $stmt_clib->bindValue(':clave', $cveDoc);

            foreach ($campos_libres as $campo => $valor) {
                $stmt_clib->bindValue(":$campo", $valor);
            }

            try {
                $stmt_clib->execute();
            } catch (PDOException $e) {
                echo "Error al insertar campos libres: " . $e->getMessage();
            }
        } else {
            echo "Insertando solo CLAVE_DOC";

            $sql_clib = "INSERT INTO COMPC_CLIB01 (CLAVE_DOC) VALUES (:clave)";
            $stmt_clib = $dbh->prepare($sql_clib);
            $stmt_clib->bindValue(':clave', $cveDoc);
            $stmt_clib->execute();
        }


        /* Partidas (PAR_COMPC01) */
        // tipo de moneda en COMPC01
        $sqlMoneda = "SELECT NUM_MONED FROM COMPC01 WHERE CVE_DOC = :cveDoc";
        $stmtMoneda = $dbh->prepare($sqlMoneda);
        $stmtMoneda->bindParam(':cveDoc', $cveDoc);
        $stmtMoneda->execute();
        $moneda = $stmtMoneda->fetch(PDO::FETCH_ASSOC)['NUM_MONED'] ?? null;

        // Tipo de Almacen en COMPC01
        $sqlInv = "SELECT NUM_ALMA FROM COMPC01 WHERE CVE_DOC = :cveDoc";
        $stmtInv = $dbh->prepare($sqlInv);
        $stmtInv->bindParam(':cveDoc', $cveDoc);
        $stmtInv->execute();
        $Inv = $stmtInv->fetch(PDO::FETCH_ASSOC)['NUM_ALMA'] ?? null;

        // OBS_DOC01 Por cada partida 
        $stmtObs = $dbh->query("SELECT MAX(CVE_OBS) AS LAST_OBS FROM OBS_DOCC01");
        $lastObs = $stmtObs->fetch(PDO::FETCH_ASSOC)['LAST_OBS'] ?? 0;
        $newObs = $lastObs + 1;
        $sqlObs = "INSERT INTO OBS_DOCC01 (CVE_OBS, STR_OBS) VALUES (:cve_obs, :str_obs)";
        $stmtObsInsert = $dbh->prepare($sqlObs);
        foreach ($_POST['productos'] as $index => $producto) {
            $numPar = $index + 1;
            $cveObs = 0;

            if (!empty($producto['observaciones'])) {
                // Insertar la observación y obtener el nuevo CVE_OBS
                $stmtObsInsert->execute([
                    ':cve_obs' => $newObs,
                    ':str_obs' => $producto['observaciones']

                ]);

                $cveObs = $newObs; // Asignar el nuevo consecutivo
                $newObs++; // Incrementar para la siguiente observación
            }
        }

        // Tipo de Elemento (PAR_COMPC01)
        $sqlTipoElem = "SELECT TIPO_ELE FROM INVE01 WHERE CVE_ART = :cveArt";
        $stmtTipoElem = $dbh->prepare($sqlTipoElem);
        $stmtTipoElem->bindParam(':cveArt', $producto['producto']);
        $stmtTipoElem->execute();
        $tipoElem = $stmtTipoElem->fetch(PDO::FETCH_ASSOC)['TIPO_ELE'] ?? null;

        // Impuestos a plazos segun el Esquema de Impuestos (PAR_COMPC01)
        $sqlimpu = "SELECT IMP1APLICA, IMP2APLICA, IMP3APLICA, IMP4APLICA FROM IMPU01 WHERE CVE_ESQIMPU = ?";
        $stmtimpu = $dbh->prepare($sqlimpu);
        $stmtimpu->execute([$esquema2]);
        $resultado = $stmtimpu->fetch(PDO::FETCH_ASSOC);

        if ($resultado) {
            $imp1Apla = $resultado['IMP1APLICA'];
            $imp2Apla = $resultado['IMP2APLICA'];
            $imp3Apla = $resultado['IMP3APLICA'];
            $imp4Apla = $resultado['IMP4APLICA'];
        } else {
            $imp1Apla = 0;
            $imp2Apla = 0;
            $imp3Apla = 0;
            $imp4Apla = 0;
        }

        // Numero de movimiento de PAR_COMPC01 y de MINVE01 (esta aqui por que la variable se le primero)
        $stmtMov = $dbh->query("SELECT MAX(CAST(NUM_MOV AS INTEGER)) AS LAST_MOV FROM MINVE01");
        $lastNumMov = $stmtMov->fetch(PDO::FETCH_ASSOC)['LAST_MOV'] ?? 0;
        $lastNumMov = (int) $lastNumMov;
        $newNumMov = $lastNumMov + 1;

        // Consulta para obtener los campos libres disponibles
        $query_campos_libres = "SELECT CAMPO FROM PARAM_CAMPOSLIBRES01 WHERE IDTABLA = 'PAR_COMPC_CLIB'";
        $stmt_campos1 = $dbh->prepare($query_campos_libres);
        $stmt_campos1->execute();
        $campos_disponibles = $stmt_campos1->fetchAll(PDO::FETCH_COLUMN);

        // Total de Impuestos en las Partidas si no hay datos
        $totalImpuesto1 = 0;
        $totalImpuesto2 = 0;
        $totalImpuesto3 = 0;
        $totalImpuesto4 = 0;
        $totalDescuento = 0;
        $totalimporte = 0;

        // Inicio de Inserción de datos en PAR_COMPC01
        $sql2 = "INSERT INTO PAR_COMPC01 (
                CVE_DOC, NUM_PAR, CANT, CVE_ART, UNI_VENTA,
                DESCU, IMPU1, IMPU2, IMPU3, IMPU4, COST, NUM_MOV,
                TOT_PARTIDA, COST_DEV, TIPO_PROD, FACTCONV, TIP_CAM, TOTIMP1, TOTIMP2, TOTIMP3, TOTIMP4,
                NUM_ALM, MINDIRECTO, CVE_ESQ,
                PXR, PREC, IMP1APLA, IMP2APLA, IMP3APLA, IMP4APLA, ACT_INV, TIPO_ELEM, CVE_OBS,
                MAN_IEPS, APL_MAN_IMP, CUOTA_IEPS, APL_MAN_IEPS, MTO_PORC, MTO_CUOTA
            ) VALUES (
                :cveDoc, :numPar, :cantidad, :producto, :unidad,
                :descuento, :ieps, :ret_isr, :ret_iva, :iva, :costo_unidad, :numMov,
                :subtotal_partida, :cost_dev, :tipo_prod, '1', :tipCam, :totImp1, :totImp2, :totImp3, :totImp4,
                :Inv, :gastosindi, :esquema2,
                :pendientes, '0', :imp1Apla, :imp2Apla, :imp3Apla, :imp4Apla, 'S', 'N', :cveObs,
                'N', '1', '0', 'C', '0', '0'
            )";
        $stmt2 = $dbh->prepare($sql2);

        foreach ($_POST['productos'] as $index => $producto) {
            $numPar = $index + 1;
            $paramCantidad = $producto['cantidad'];

            $porcentajeIeps = $producto['ieps'] / 100;
            $porcentajeRetIsr = $producto['ret_isr'] / 100;
            $porcentajeRetIva = $producto['ret_iva'] / 100;
            $porcentajeIva = $producto['iva'] / 100;
            $porcentajeDescuento = $producto['descuento'] / 100;
            $porcentajeDescuentoFin = $descuentofinal / 100;

            // 1. Subtotal sin descuentos
            $subtotalSinDescuentos = $producto['subtotal_partida'];

            // 2. Descuento normal
            $descuentoCalculado = $subtotalSinDescuentos * $porcentajeDescuento;
            $subtotalConDescuento = $subtotalSinDescuentos - $descuentoCalculado;

            // 3. Descuento financiero sobre subtotal con descuento
            $descuentoFinancieroCalculado = $subtotalConDescuento * $porcentajeDescuentoFin;
            $subtotalFinalAntesImpuestos = $subtotalConDescuento - $descuentoFinancieroCalculado;

            // COST_DEV = subtotal con descuento normal
            $cost_dev = $subtotalConDescuento;

            // 4. Impuestos aplicados al final
            $totImp1 = $subtotalFinalAntesImpuestos * $porcentajeIeps;
            $totImp2 = $subtotalFinalAntesImpuestos * $porcentajeRetIsr;
            $totImp3 = $subtotalFinalAntesImpuestos * $porcentajeRetIva;
            $totImp4 = $subtotalFinalAntesImpuestos * $porcentajeIva;

            // 5. Total final de la partida
            $totalPartidaFinal = $subtotalFinalAntesImpuestos + $totImp1 + $totImp2 + $totImp3 + $totImp4;

            // 6. Acumuladores
            $totalImpuesto1 += $totImp1;
            $totalImpuesto2 += $totImp2;
            $totalImpuesto3 += $totImp3;
            $totalImpuesto4 += $totImp4;
            $totalDescuento += $descuentoCalculado;
            $totalDescuentoFinanciero += $descuentoFinancieroCalculado;
            $totalimporte += $totalPartidaFinal;

            // Bind para PAR_COMPC01
            $stmt2->bindParam(':cveDoc', $cveDoc);
            $stmt2->bindParam(':numPar', $numPar);
            $stmt2->bindParam(':cantidad', $paramCantidad);
            $stmt2->bindParam(':producto', $producto['producto']);
            $stmt2->bindParam(':unidad', $producto['unidad']);
            $stmt2->bindParam(':descuento', $producto['descuento']);
            $stmt2->bindParam(':ieps', $producto['ieps']);
            $stmt2->bindParam(':ret_isr', $producto['ret_isr']);
            $stmt2->bindParam(':ret_iva', $producto['ret_iva']);
            $stmt2->bindParam(':iva', $producto['iva']);
            $stmt2->bindParam(':costo_unidad', $producto['costo_unidad']);
            $stmt2->bindParam(':numMov', $newNumMov);
            $stmt2->bindParam(':subtotal_partida', $producto['subtotal_partida']);
            $stmt2->bindParam(':cost_dev', $cost_dev);
            $stmt2->bindParam(':tipo_prod', $tipoElem);
            $stmt2->bindParam(':tipCam', $moneda);
            $stmt2->bindParam(':Inv', $Inv);
            $stmt2->bindParam(':gastosindi', $producto['gastosind']);
            $stmt2->bindParam(':esquema2', $_POST['esquema2']);
            $stmt2->bindParam(':pendientes', $paramCantidad);
            $stmt2->bindParam(':totImp1', $totImp1);
            $stmt2->bindParam(':totImp2', $totImp2);
            $stmt2->bindParam(':totImp3', $totImp3);
            $stmt2->bindParam(':totImp4', $totImp4);
            $stmt2->bindParam(':imp1Apla', $imp1Apla);
            $stmt2->bindParam(':imp2Apla', $imp2Apla);
            $stmt2->bindParam(':imp3Apla', $imp3Apla);
            $stmt2->bindParam(':imp4Apla', $imp4Apla);
            $stmt2->bindParam(':cveObs', $cveObs);
            $stmt2->execute();

            if (isset($producto['campos_libres']) && is_array($producto['campos_libres']) && count($producto['campos_libres']) > 0) {
                $campos = $producto['campos_libres'];
                $campos_nombres = implode(", ", array_keys($campos));
                $campos_placeholders = implode(", ", array_map(fn($c) => ":$c", array_keys($campos)));

                $sql_clib = "INSERT INTO PAR_COMPC_CLIB01 (CLAVE_DOC, NUM_PART, $campos_nombres) 
                    VALUES (:cveDoc, :numPar, $campos_placeholders)";

                $stmt_clib = $dbh->prepare($sql_clib);
                $stmt_clib->bindValue(':cveDoc', $cveDoc);
                $stmt_clib->bindValue(':numPar', $index + 1);

                foreach ($campos as $campo => $valor) {
                    $valor = trim($valor);
                    $stmt_clib->bindValue(":$campo", $valor === "" ? null : $valor);
                }

                $stmt_clib->execute();
            } else {
                // Insertar solo CLAVE_DOC y NUM_PART si no hay campos libres para la partida
                $sql_clib = "INSERT INTO PAR_COMPC_CLIB01 (CLAVE_DOC, NUM_PART) VALUES (:cveDoc, :numPar)";
                $stmt_clib = $dbh->prepare($sql_clib);
                $stmt_clib->bindValue(':cveDoc', $cveDoc);
                $stmt_clib->bindValue(':numPar', $index + 1);
                $stmt_clib->execute();
            }
        }


        /* OMINVE01 Por cada partida  */
        $stmtOmi = $dbh->query("SELECT MAX(CVE_OBS) AS LAST_OBS FROM OMINVE01");
        $lastOmi = $stmtOmi->fetch(PDO::FETCH_ASSOC)['LAST_OBS'] ?? 0;
        $newOmi = $lastOmi + 1;
        $sqlOmi = "INSERT INTO OMINVE01 (CVE_OBS, STR_OBS) VALUES (:cve_obs, :str_obs)";
        $stmtOmiInsert = $dbh->prepare($sqlOmi);
        foreach ($_POST['productos'] as $index => $producto) {
            $numPar = $index + 1;

            if (!empty($producto['observaciones'])) {
                // Insertar la observación y obtener el nuevo CVE_OBS
                $stmtOmiInsert->execute([
                    ':cve_obs' => $newOmi,
                    ':str_obs' => $producto['observaciones']
                ]);
                $newOmi++; // Incrementar para la siguiente observación
            }
        }

        /* MINVE01 */

        // Obtener el último folio registrado en MINVE01 y asegurar que sea un número
        $stmtFolio = $dbh->query("SELECT MAX(CAST(CVE_FOLIO AS INTEGER)) AS LAST_FOLIO FROM MINVE01");
        $lastFolio = $stmtFolio->fetch(PDO::FETCH_ASSOC)['LAST_FOLIO'] ?? 0;
        $lastFolio = (int) $lastFolio;
        $newFolio = $lastFolio + 1;
        $folioActual = $newFolio;

        // Obtener el último número de movimiento
        $stmtMov = $dbh->query("SELECT MAX(NUM_MOV) AS LAST_MOV FROM MINVE01");
        $lastMov = $stmtMov->fetch(PDO::FETCH_ASSOC)['LAST_MOV'] ?? 0;
        $newNumMov = (int) $lastMov + 1;

        // Preparar consulta para obtener existencias
        $sqlExistencias = "SELECT EXIST FROM INVE01 WHERE CVE_ART = :cveArt";
        $stmtExistencias = $dbh->prepare($sqlExistencias);

        foreach ($_POST['productos'] as $producto) {
            $stmtExistencias->execute([':cveArt' => $producto['producto']]);
            $existencias = $stmtExistencias->fetchColumn();

            if ($existencias === false || $existencias === null) {
                $existencias = 0; // Si no hay registro, asumimos existencias en 0
            }

            $nuevaExistencia = $existencias + $producto['cantidad'];

            // Insertar en MINVE01
            $sqlMINVE = "INSERT INTO MINVE01 (
                        CVE_ART, ALMACEN, NUM_MOV, CVE_CPTO, FECHA_DOCU, 
                        TIPO_DOC, REFER, CLAVE_CLPV, CANT, CANT_COST, PRECIO,
                        COSTO, REG_SERIE, UNI_VENTA, E_LTPD, EXIST_G, EXISTENCIA, FACTOR_CON, FECHAELAB, CVE_FOLIO,
                        SIGNO, COSTEADO, DESDE_INVE
                        ) VALUES (
                        :cveArt, :almacen, :numMov, 1, :fechaDocu, 
                        :tipoDoc, :refer, :proveedor, :cant, :cantCost, 0,
                        :costo, 0, :uniVenta, 0, :exist_g, :existencias, 1, :fechaElab, :cveFolio,
                        1, 'S', 'S'
                        )";

            $stmtMINVE = $dbh->prepare($sqlMINVE);
            $stmtMINVE->execute([
                ':cveArt' => $producto['producto'],
                ':almacen' => $_POST['almacen'],
                ':numMov' => $newNumMov,
                ':fechaDocu' => $fechaDoc,
                ':tipoDoc' => 'c',
                ':refer' => $_POST['cveDoc'],
                ':proveedor' => $_POST['proveedor'],
                ':cant' => $producto['cantidad'],
                ':cantCost' => $producto['cantidad'],
                ':costo' => $producto['costo_unidad'],
                ':uniVenta' => $producto['unidad'],
                ':exist_g' => $nuevaExistencia,
                ':existencias' => $existencias,
                ':fechaElab' => date('Y-m-d H:i:s'),
                ':cveFolio' => $folioActual
            ]);
            // Actualizar existencias en INVE01
            $sqlUpdateExistencias = "UPDATE INVE01 SET 
            EXIST = COALESCE(EXIST, 0) + :cantidad, 
            FCH_ULTCOM = :fechaUltCompra 
            WHERE CVE_ART = :cveArt";
            $stmtUpdateExistencias = $dbh->prepare($sqlUpdateExistencias);
            $stmtUpdateExistencias->execute([
                ':cantidad' => $producto['cantidad'],
                ':fechaUltCompra' => date('Y-m-d'),
                ':cveArt' => $producto['producto']
            ]);

            $newNumMov++;
        }
        $newFolio++;

        /* INSERTA DATOS DE PAGOS EN PAGA_M01 (Modal: Pagos a plazos)*/
        // Genera un pago por defecto si no se abrió la modal ni se enviaron pagos
        if (!isset($_POST['pagos']) || !is_array($_POST['pagos']) || empty($_POST['pagos'])) {
            $fecha_venc = $_POST['fechaplazo'] ?? date('Y-m-d');

            $monto_total = $totalPartidaFinal ?? 0;

            $_POST['pagos'] = [[
                'fecha' => $fecha_venc,
                'monto' => $monto_total
            ]];
        }
        /* INSERTA DATOS DE PAGOS EN PAGA_M01 (Modal: Pagos a plazos)*/
        if (isset($_POST['pagos']) && is_array($_POST['pagos'])) {
            $pagos = $_POST['pagos'];
            $conceptos = $_POST['concepto'];

            $sqlPAGA = "INSERT INTO PAGA_M01 (
                CVE_PROV, REFER, NUM_CARGO, NUM_CPTO, CVE_OBS,
                DOCTO, IMPORTE, FECHA_APLI, FECHA_VENC,
                NUM_MONED, TCAMBIO, IMPMON_EXT, SIGNO,
                FECHAELAB, TIPO_MOV, USUARIO, STATUS
            ) VALUES (
                :proveedor, :refer, :num_cargo, :num_cpto, :cveobspa,
                :docto, :importe, :fecha_apli, :fecha_venc,
                :num_mone, :tipocambio, :impmon_ext, 1,
                :fechalab, 'C', 0, 'A'
            )";

            $stmtPAGA = $dbh->prepare($sqlPAGA);
            $num_cargo = 1;

            $fecha_aplicacion_fija = $_POST['fechaplazo'];

            foreach ($pagos as $index => $pago) {
                $fecha = $pago['fecha'];
                $monto = $pago['monto'];
                $num_cpto = isset($conceptos[$index]) ? $conceptos[$index] : 0; // ← valor individual

                $fechalab = DateTime::createFromFormat('U.u', microtime(true))->format('Y-m-d H:i:s.v');

                $stmtPAGA->bindParam(':proveedor', $proveedor);
                $stmtPAGA->bindParam(':refer', $cveDoc);
                $stmtPAGA->bindParam(':num_cargo', $num_cargo);
                $stmtPAGA->bindParam(':num_cpto', $num_cpto); // ← aquí ya es el correcto   
                $stmtPAGA->bindParam(':cveobspa', $cveObs);
                $stmtPAGA->bindParam(':docto', $cveDoc);
                $stmtPAGA->bindParam(':importe', $monto);
                $stmtPAGA->bindParam(':fecha_apli', $fecha_aplicacion_fija);
                $stmtPAGA->bindParam(':fecha_venc', $fecha);
                $stmtPAGA->bindParam(':num_mone', $tipomoneda);
                $stmtPAGA->bindParam(':tipocambio', $moneda);
                $stmtPAGA->bindParam(':impmon_ext', $monto);
                $stmtPAGA->bindParam(':fechalab', $fechalab);
                $stmtPAGA->execute();

                $num_cargo++;
            }
        }

        /* Agrega datos a la tabla de PAGA_DET01 (Modal: Emision de pagos) */
        try {
            $sqlpagadet = "INSERT INTO PAGA_DET01 (
                CVE_PROV, REFER, NUM_CPTO, NUM_CARGO, ID_MOV, CVE_OBS,
                DOCTO, IMPORTE, FECHA_APLI, FECHA_VENC, NUM_MONED, TCAMBIO,
                IMPMON_EXT, FECHAELAB, CTLPOL, TIPO_MOV, SIGNO, CVE_AUT,
                USUARIO, NO_PARTIDA
            ) VALUES (
                :proveedor, :refer, :num_cpto, :num_cargo, 1, :cveobsdet,
                :docto, :importe, :fecha_apli, :fecha_venc, :num_moneda, :tcambio,
                :impmon_exte, :fechalabora, 0, 'A', -1, 0,
                0, :no_partida
            )";

            $stmtpagadet = $dbh->prepare($sqlpagadet);

            $conceptos = $_POST['concepto'];
            $documentos_ref = $_POST['documento_ref'];
            $montos = $_POST['montos'];

            $num_cargos = 1;
            $fechalabora = (new DateTime())->format('Y-m-d H:i:s.v');

            for ($i = 0; $i < count($conceptos); $i++) {
                $num_cpto = isset($conceptos[$i]) ? (int)$conceptos[$i] : 0;
                $docto = isset($documentos_ref[$i]) ? $documentos_ref[$i] : '';
                $importe = isset($montos[$i]) ? floatval($montos[$i]) : 0;

                // Insertar solo si concepto válido y monto > 0 (permite documento vacío)
                if ($num_cpto > 0 && $importe > 0) {
                    $stmtpagadet->bindValue(':proveedor', $proveedor);
                    $stmtpagadet->bindValue(':refer', $cveDoc);
                    $stmtpagadet->bindValue(':num_cpto', $num_cpto);
                    $stmtpagadet->bindValue(':num_cargo', $num_cargos);
                    $stmtpagadet->bindValue(':cveobsdet', $cveObs);
                    $stmtpagadet->bindValue(':docto', $docto);
                    $stmtpagadet->bindValue(':importe', $importe);
                    $stmtpagadet->bindValue(':fecha_apli', $fechaDoc);
                    $stmtpagadet->bindValue(':fecha_venc', $fechaDoc);
                    $stmtpagadet->bindValue(':num_moneda', $tipomoneda);
                    $stmtpagadet->bindValue(':tcambio', $moneda);
                    $stmtpagadet->bindValue(':impmon_exte', $importe);
                    $stmtpagadet->bindValue(':fechalabora', $fechalabora);
                    $stmtpagadet->bindValue(':no_partida', $num_cpto);

                    $stmtpagadet->execute();
                    $num_cargos++;
                }
            }
        } catch (PDOException $e) {
            echo "Error al insertar el registro: " . $e->getMessage();
        }

        /* Actualiza datos de PROV01  */
        $sqlProveedor = "UPDATE PROV01 SET 
        ULT_COMPD = :cveDoc,
        ULT_COMPM = :ult_montoprov,
        ULT_COMPF = :ult_fechaprov
        WHERE CLAVE = :proveedor";
        $stmtProveedor = $dbh->prepare($sqlProveedor);
        $stmtProveedor->bindParam(':cveDoc', $cveDoc);
        $stmtProveedor->bindParam(':ult_montoprov', $totalimporte);
        $stmtProveedor->bindParam(':ult_fechaprov', $fechaDoc);
        $stmtProveedor->bindParam(':proveedor', $proveedor);
        $stmtProveedor->execute();

        /*  Actualizar la columna IMPORTE en COMPC01 */
        $sqlUpdate = "UPDATE COMPC01 SET 
        IMP_TOT1 = :totalImpuesto1,
        IMP_TOT2 = :totalImpuesto2,
        IMP_TOT3 = :totalImpuesto3,
        IMP_TOT4 = :totalImpuesto4,
        DES_TOT = :totalDescuento,
        DES_FIN = :descuentofin,
        IMPORTE = :totalimporte
        WHERE CVE_DOC = :cveDoc";
        $stmtUpdate = $dbh->prepare($sqlUpdate);
        $stmtUpdate->bindParam(':totalImpuesto1', $totalImpuesto1);
        $stmtUpdate->bindParam(':totalImpuesto2', $totalImpuesto2);
        $stmtUpdate->bindParam(':totalImpuesto3', $totalImpuesto3);
        $stmtUpdate->bindParam(':totalImpuesto4', $totalImpuesto4);
        $stmtUpdate->bindParam(':totalDescuento',  $totalDescuento );
        $stmtUpdate->bindParam(':descuentofin', $totalDescuentoFinanciero);
        $stmtUpdate->bindParam(':totalimporte', $totalimporte);
        $stmtUpdate->bindParam(':cveDoc', $cveDoc);
        $stmtUpdate->execute();

    if ($stmt2->rowCount() > 0) {
        echo json_encode([
            'success' => true,
            'message' => 'Registro hecho correctamente.',
            'new_cve_doc' => $cveDoc
        ], JSON_UNESCAPED_UNICODE);
    } else {
        // Ninguna fila afectada
        http_response_code(500);          
        echo json_encode([
            'success' => false,
            'message' => 'No se pudo registrar el documento.'
        ]);
    }
} catch (Throwable $e) {                 
    http_response_code(500);             
    echo json_encode([
        'success' => false,
        'message' => 'Error: ' . $e->getMessage()
    ]);
}}
exit;
?>