<?php
$configPath = substr(__DIR__, 0, strpos(__DIR__, "/public_html")) . "/config.php";
require_once $configPath;
require_once __DIR__ . "/../inc/npa_import.class.php";

//define("__VERBOSE", 1);

$modulo_riferimento = $_REQUEST["modulo_riferimento"] ?? null;
$moduli_supportati = ["gare", "concorsi"];
if (!in_array($modulo_riferimento, $moduli_supportati)) {
    swalDie("Sono supportati solo " . implode(', ', $moduli_supportati));
}

$filterAppalto = [];

$userCF = $saCF = $saAUSA = "";

if (isset($_SESSION["utente"]) && isset($_SESSION["ente"]) && (!defined("__CMDS_JOB_EXEC") || empty(__CMDS_JOB_EXEC))) {
    $userCF = $_SESSION["utente"]->getInfo()["cf"];

    $ente = (!empty($_SESSION["utente"]->codice_ente)) ? $_SESSION["utente"]->codice_ente : $_SESSION["ente"]->codice;
    if (!empty($ente)) {
        $ente = Ente::getInfoFromID($ente);
        if (!empty($ente)) {
            $ente = reset($ente);
            if (!empty($ente["cf"]) && !empty($ente["codice_ausa"]) && $ente["cf"] != $saCF) {
                $saCF = $ente["cf"];
                $saAUSA = $ente["codice_ausa"];
            }
        }
    }
}


$hasClaimsData = !empty($_REQUEST["codiceFiscale"]) && !empty($_REQUEST["codiceAusa"]);
$claimData = [
    "userCodiceFiscale" => $userCF,
    "codiceFiscale" => !empty($_REQUEST["codiceFiscale"]) ? $_REQUEST["codiceFiscale"] : $saCF,
    "codiceAusa" => !empty($_REQUEST["codiceAusa"]) ? $_REQUEST["codiceAusa"] : $saAUSA,
];

// Possibili ricerche per appalto
foreach (["cig", "codiceAppalto"] as $term) {
    if (empty($_REQUEST[$term])) continue;
    $filterAppalto[$term] = trim($_REQUEST[$term]);
    $cacheKey = $term;
    $cacheValue = $filterAppalto[$term];
    break;
}


if (empty($filterAppalto) || !$hasClaimsData) {
    // Mostriamo la UI di ricerca
    require __DIR__ . "/../inc/components/import/search.php";
    die();
}


$appalto = null;
// Usiamo un backup se è stato chiesto all'utente di integrare la procedura da poco
if (($_SESSION["npa_import"]["expiration"] ?? 0) > time() && (($_SESSION["npa_import"][$cacheKey] ?? "") == $cacheValue)) {
    $appalto = $_SESSION["npa_import"]["appalto"];
}

// Inizializziamo ANAC
$npa = NuovaPiattaformaAppalti::initStatic();
$npa->initFakeOggetto($modulo_riferimento);
$npa->overrideStazioneAppaltante = $claimData;
if ($appalto === null) {
    // Cerchiamo l'appalto
    $response_ricerca_appalto = $npa->apiCall("comunicaAppalto", "search", $filterAppalto);
    $response_ricerca_appalto = json_decode($response_ricerca_appalto);

    if (!isset($response_ricerca_appalto->result)) {
        swalDie("Risposta non valida dai server ANAC. Verifica di essere RP e prova più tardi.");
    }
    if (empty($response_ricerca_appalto->result)) {
        swalDie("Impossibile trovare l'appalto. Verifica che il CF e Codice Ausa della Stazione Appaltante siano corretti.");
    }

    $appalto = $response_ricerca_appalto->result[0];
    if (empty($appalto->idAppalto)) {
        swalDie("L'appalto non possiede un idAppalto.");
    }

    // Otteniamo le schede
    $response_schede = $npa->apiCall("comunicaPostPubblicazione", "search", ["idAppalto" => $appalto->idAppalto]);
    $response_schede = json_decode($response_schede);

    if (empty($response_schede->result)) {
        swalDie("Impossibile trovare le schede legate a questo appalto.");
    }

    $appalto->schede = $response_schede->result;


    // Prendiamo solo l'ultima versione CONF di schede non ripetibili
    $appalto->schede = array_filter($appalto->schede, function ($scheda) {
        return $scheda->stato->codice == "CONF";
    });

    $esiti_request = [
        "idAppalto" => $appalto->idAppalto,
        "tipoOperazione" => "SC_CONF",
        "tipoRicerca" => "TUTTI_ESITI",
    ];
    $esiti = $npa->apiCall("serviziComuni", "result", $esiti_request);
    $esiti = json_decode($esiti);
    // Ricerca idContratto
    foreach($appalto->schede as &$scheda) {
        foreach($esiti->listaEsiti ?? [] as $esito) {
            if($esito->idScheda != $scheda->_idScheda || empty($esito->idContratto)) continue;
            $scheda->body->anacForm->idContratto = $esito->idContratto;
            // Cerchiamo il CIG
            $anacForm = object_to_array($scheda->body->anacForm);

            $cig = recursive_array_key_search_first("cig", $anacForm);
            $lotIdentifier = recursive_array_key_search_first("lotIdentifier", $anacForm);
            if(!empty($cig) || !empty($lotIdentifier)) {
                foreach ($appalto->lotti as $index => &$lotto) {
                    if($lotto->cig == $cig || $lotto->lotIdentifier == $lotIdentifier) {
                        $lotto->idContratto[] = $esito->idContratto;
                    }
                }
            }
            break;
        }
    }
    unset($scheda);
    unset($lotto);

    // Otteniamo le pubblicazioni
    $response_pubblicazioni = $npa->apiCall("pubblicazioneAvvisi", "search", ["idAppalto" => $appalto->idAppalto]);
    $response_pubblicazioni = json_decode($response_pubblicazioni);
    foreach ($response_pubblicazioni->result as $r) {
        $result = $npa->apiCall("pubblicazioneAvvisi", "read", ["idAvviso" => $r->idAvviso]);
        $result = json_decode($result);
        foreach ($appalto->schede as &$scheda) {
            if ($scheda->_idScheda == $result->scheda->_idScheda) {
                $scheda->pubblicazione = $result->avviso;
            }
        }
    }

    // Otteniamo la scheda principale
    $response_appalto = $npa->apiCall(
        "comunicaAppalto",
        "read",
        ["idAppalto" => $appalto->idAppalto]
    );
    $response_appalto = json_decode($response_appalto);
    if (!isset($response_appalto->appalto->scheda)) {
        swalDie("Impossibile determinare la scheda iniziale");
    }

    $appalto->schedaPrincipale = $response_appalto->appalto->scheda;
}
vdump("Appalto secondo ANAC:", $appalto);


if(!DEVELOP_ENV) {
    // Verifichiamo che l'appalto non sia già presente in questo tenant
    foreach($appalto->lotti as $lotto) {
        if(!empty(NuovaPiattaformaAppalti::fetchLotti(["*"], ["cig" => $lotto->cig], true))) {
            swalDie("Un lotto con CIG {$lotto->cig} è già presente in piattaforma");
        }
    }
    if(!empty(NuovaPiattaformaAppalti::fetchDossier(["*"], ["id_appalto" => $appalto->idAppalto]))) {
        swalDie("Un fascicolo ANAC con idAppalto {$appalto->idAppalto} è già presente in piattaforma");
    }
}


// Cerchiamo di determinare il match-moduli
$codice_prima_scheda = $appalto->schedaPrincipale->codice->codice;
$match_moduli = NuovaPiattaformaAppalti::getCategorizedCardsList();

// Cerchiamo questa scheda nel match moduli
$risultati = recursive_array_search_all($codice_prima_scheda, $match_moduli);
$risultati_compatibili = array_filter($risultati, function ($item) use ($modulo_riferimento) {
    return $item[0] == $modulo_riferimento;
});
if (empty($risultati_compatibili)) {
    #sostituire la throw con un messaggio che ritorni i moduli compatibili
    throw new Exception("Questa gara non è compatibile con il modulo {$modulo_riferimento}");
}

$procedura = null;
$settoreRiferimento = null;
// Ottenimento della procedura
if ($modulo_riferimento === "gare") {
    // Vediamo se l'utente ha specificato manualmente una procedura
    $procedura = $_REQUEST["procedura"] ?? null;
    if (empty($procedura)) {
        $procedura = NPA_Import::getProcedura($appalto->schedaPrincipale, $risultati_compatibili);
        // Se ci è stata ritornata più di una procedura (O nessuna)...
        if (is_array($procedura)) {
            // Prendiamo quelle compatibili
            if (empty($procedura)) {
                $procedura = array_keys($match_moduli[$modulo_riferimento]["procedure"]);
                $procedura = array_filter($procedura, function ($item) {
                    return $item != "*";
                });
            }

            // Facciamo un backup dell'appalto per non dover ricontattare ANAC

            $_SESSION["npa_import"] = [
                "appalto" => $appalto,
                "expiration" => time() + 5 * 60,
                $cacheKey => $cacheValue
            ];
            // E chiediamo all'utente
            require __DIR__ . "/../inc/components/import/procedura.php";
            die();
        }
    }
    // Vediamo se l'utente ha specificato manualmente un settoreRiferimento
    $settoreRiferimento = $_REQUEST["settoreRiferimento"] ?? null;
    if (empty($settoreRiferimento)) {
        $settoreRiferimento = NPA_Import::getSettoreRiferimento($appalto->schedaPrincipale);
        // Se ci è stata ritornata più di una procedura (O nessuna)...
        if (is_array($settoreRiferimento)) {
            // Prendiamo quelle compatibili
            if (empty($settoreRiferimento)) {
                $settoreRiferimento = ["ordinario", "speciale", "sicurezza"];
            }

            // Facciamo un backup dell'appalto per non dover ricontattare ANAC

            $_SESSION["npa_import"] = [
                "appalto" => $appalto,
                "expiration" => time() + 5 * 60,
                $cacheKey => $cacheValue
            ];
            // E chiediamo all'utente
            require __DIR__ . "/../inc/components/import/settoreRiferimento.php";
            die();
        }
    }


    $codiceCPV = $_REQUEST["cpv"] ?? [];
    // CPV Autoselezionata 
    if(empty($codiceCPV)) {
        foreach ($appalto->lotti as $index => &$lotto) {
            $infoLotto = NPA_Import::getInfoLotto($appalto->schede, $lotto);
            if(!empty($infoLotto["cpvPrevalente"])) {
                $cpvPrevalente = $pdo->go("SELECT codice FROM b_cpv WHERE codice = :codice", [":codice" => $infoLotto["cpvPrevalente"]])->fetch(PDO::FETCH_ASSOC);
                if(!empty($cpvPrevalente)) {
                    $codiceCPV[] = $cpvPrevalente["codice"];
                }
            }
        }
        if(empty($codiceCPV)) {
            // Facciamo un backup dell'appalto per non dover ricontattare ANAC
            $_SESSION["npa_import"] = [
                "appalto" => $appalto,
                "expiration" => time() + 5 * 60,
                $cacheKey => $cacheValue
            ];
            // E chiediamo all'utente
            require __DIR__ . "/../inc/components/import/cpv.php";
            die();
        }
    // CPV Ottenute dall'utente
    } else {
        $userCPV = $codiceCPV;
        $codiceCPV = [];
        foreach($userCPV as $codice) {
            $cpv = $pdo->go("SELECT codice FROM b_cpv WHERE codice = :codice", [":codice" => $codice])->fetch(PDO::FETCH_ASSOC);
            if(!empty($cpv)) {
                $codiceCPV[] = $cpv["codice"];
            }
        }
    }
}
$hasPartecipanti = false;
$hasAggiudicatari = false;
// Creazione dell'oggetto
switch ($modulo_riferimento) { //crea il fascicolo<
    case 'gare':

        //$extraInfo section
        $nuts = NPA_Import::getNuts($appalto->schede);
        $norma_riferimento = NPA_Import::getNormaRiferimento($appalto->schede);
        $importi = NPA_Import::getImporti($appalto->schedaPrincipale);
        $tipologia =  NPA_Import::getTipologia($appalto->schedaPrincipale);

        // Tentativo di recupero da affidamento diretto
        if(empty($importi)) {
            $importoAggiudicazioniLotto = 0;
            foreach ($appalto->lotti as $index => &$lotto) {
                $infoLotto = NPA_Import::getInfoLotto($appalto->schede, $lotto);
                $importoAggiudicazioniLotto += $infoLotto["importoPartecipanti"] ?? 0;
            }

            $tipoImporto = "servizi";
            switch ($tipologia) {
                case "L":
                    $tipoImporto = "lavori";
                    break;
                case "F":
                    $tipoImporto = "forniture";
                    break;
                default:
                    break;
            }
            $importi[$tipoImporto] = $importoAggiudicazioniLotto;
        }
        $rinnovi = $importi["rinnovi"] ?? 0;
        unset($importi["rinnovi"]);
        $somma_amministrazione = $importi["sommeAmministrazione"] ?? 0;
        unset($importi["sommeAmministrazione"]);

        $enteBeneficiario = NPA_Import::getEnteBeneficiario($appalto->schedaPrincipale);

        $enteCodiceAusa = $enteBeneficiario["codiceAusa"] ?? "";
        $enteCodiceFiscale = $enteBeneficiario["codiceFiscale"] ?? "";

        if(!empty($enteCodiceAusa)) {
            // Proviamo prima a cercarlo tramite codiceAusa
            $ente = ente::fetchEnti(["*"], [
                "codice_ausa" => $enteCodiceAusa,
            ], false);
        }

        // Proviamo poi a cercerlo tramite codiceFiscale
        if(empty($ente) && !empty($codiceFiscale)) {
            $ente = ente::fetchEnti(["*"], [
                "cf" => $enteCodiceFiscale,
            ], false);
        }

        if(empty($ente)) {
            swalDie("Impossibile trovare l'ente beneficiario con CF: {$enteCodiceFiscale} o AUSA: {$enteCodiceAusa}");
        }


        $codicePEC = getPec($_SESSION["ente"]->codice);
        #IMPORTA LA GARA
        //$id = compilato dalla funzione save della gara
        $data_gara = [
            "importata" => "BDNCP",
            "oggetto" => "[Importazione BDNCP] " . $appalto->oggetto,
            "anno" => substr($appalto->dataCreazione, 0, 4),
            "stato" => 10, // Viene poi compilato più avanti
            "invito_programmato" => "N",
            "private_verified" => "N",
            "email_chiave" => null,
            "codice_ente" => $ente["codice"],
            "codice_pec" => $codicePEC,
            "procedura" => $procedura,
            "modalita" => "extra",
            "tipologia" => $tipologia,
            "accordo_quadro" => NPA_Import::getAccordoQuadro($appalto->schede) ? "S" : "N",
            "derivazione" => null,
            "fase_attiva" => 1,
            "prezzoRiferimento" => NPA_Import::getPrezzoRiferimento($appalto->schedaPrincipale),
            "contributoSUA" => 0,
            "contributoSUAVersato" => 0,
            "extraInfo" => [
                "nuts" => $nuts,
                "normaRiferimento" => $norma_riferimento,
                "importi" => $importi,
                "rinnovi" => $rinnovi,
                "sommeAmministrazione" => $somma_amministrazione
            ],
        ];

        if(!empty($codiceCPV)) {
            $data_gara["cpv"] = $codiceCPV;
        }

        vdump("Creazione gara:", $data_gara);

        $gara = gara::save($data_gara);
        $codice_gara = $gara->info["codice"];

        if (empty($gara)) {
            swalDie("Problema tecnico al salvataggio della gara.");
        }

        // Creiamo i permessi della gara
        $permesso = [];
        $permesso["sezione"] = "gare";
        $permesso["codice_elemento"] = $codice_gara;
        $permesso["funzione"] = "0";
        $permesso["codice_gestore"] = $_SESSION["ente"]->codice;
        $permesso["codice_utente"] = $_SESSION["utente"]->codice;
        $salva = new salva();
        $salva->debug = false;

        $salva->nome_tabella = "r_permessi";
        $salva->operazione = "INSERT";
        $salva->oggetto = $permesso;
        if(empty($salva->save())) {
            swalDie("Problema tecnico al salvataggio dei permessi della gara.");
        }


        $oggetto = $gara;

        // Importiamo il RUP
        $user_info = $_SESSION["utente"]->getInfo();
        $incaricato["codice_fiscale"] = trim(strtoupper($user_info["cf"]));
        $incaricato["extraInfo"] = [
            "cognome" => $user_info["cognome"],
            "nome" => $user_info["nome"],
            "email" => $user_info["email"],
        ];
        $incaricato["extraInfo"] = simple_encrypt(json_encode($incaricato["extraInfo"]), $config["simple_encrypt"]["incaricati"]);
        $incaricato["modulo"] = $modulo_riferimento;
        $incaricato["codice_elemento"] = $oggetto->info["codice"];
        $incaricato["ruolo"] = 14;
        $salva = new salva();
        $salva->debug = defined('__VERBOSE');
        $salva->nome_tabella = "b_incaricati";
        $salva->operazione = "INSERT";
        $salva->oggetto = $incaricato;
        if (empty($salva->save())) {
            swalDie("Problema tecnico alla creazione del RUP.");
        }


        // Colleghiamo l'oggetto al fascicolo NPA
        $npa->initOggetto($modulo_riferimento, $oggetto->info["codice"]);

        // Creiamo il fascicolo NPA
        $npa_data = [
            "codice_ente" => $_SESSION["ente"]->codice,
            "modulo_riferimento" => $modulo_riferimento,
            "id_riferimento" => $oggetto->info["codice"],
            "id_appalto" => $appalto->idAppalto
        ];

        vdump("Creazione fascicolo NPA", $npa_data);

        $npa->save($npa_data, false);

        if (empty($npa->fascicolo["codice"])) {
            swalDie("Impossibile creare il fascicolo ANAC");
        }
        $npa->updateFascicolo(["id_appalto" => $appalto->idAppalto]);
        $user_info = $_SESSION["utente"]->getInfo();
        $user_cf = strtoupper(trim($user_info["cf"]));

        // Importazione base dei lotti
        foreach ($appalto->lotti as $index => &$lotto) {
            $infoLotto = NPA_Import::getInfoLotto($appalto->schede, $lotto);
            $data_lot = [
                "codice_gara" => $oggetto->info["codice"],
                "stato" => 0,
                "numero" => $index+1,
                "cig" => $lotto->cig,
                "cup" => $infoLotto["cupLotto"] ?? "",
                "cpv" => $infoLotto["cpvPrevalente"] ?? "",
                "criterio" => ($infoLotto["criteriAggiudicazione"] ?? null) != "quality" ? "prezzo" : "vantaggiosa",
                "oggetto" => $lotto->oggetto,
                "descrizione" => $lotto->oggetto,
                "importoBase" => $infoLotto["importoBase"] ?? 0,
                "importoManodopera" => $infoLotto["importoManodopera"] ?? 0,
                "importoOpzioni" => $infoLotto["importoOpzioni"] ?? 0,
                "oneriNoRibasso" => $infoLotto["importoOneri"] ?? 0,
                "importoAggiudicazione" => $infoLotto["importoAggiudicazione"] ?? 0,
                "sogliaAnomalia" => null,
                "extraInfo" => null,
                "utente_creazione" => null,
                "timestamp_creazione" => null,
                "utente_modifica" => $_SESSION["utente"]->codice,
                "timestamp" => date('Y-m-d H:i:s')
            ];
            vdump("Creazione Lotto", $data_lot);
            $salva = new salva();
            $salva->debug = defined('__VERBOSE');
            $salva->nome_tabella = "b_gare_lotti";
            $salva->operazione = "INSERT";
            $salva->oggetto = $data_lot;
            $lotto->codice_lotto_oggetto = $salva->save();

            //importa i lotti di npa
            $salva = new salva();
            $salva->debug = defined('__VERBOSE');
            $salva->nome_tabella = "b_npa_lotti";
            $salva->operazione = "INSERT";
            $salva->oggetto = [
                "codice_npa" => $npa->fascicolo["codice"],
                "lotto_riferimento" => $lotto->codice_lotto_oggetto,
                "cig" => $lotto->cig,
                "utente_modifica" => $_SESSION["utente"]->codice,
            ];
            $salva->ignore = ["extraInfo", "stato"];
            $lotto->codice_lotto_npa = $salva->save();
        }
        unset($lotto);

        $fasi = $gara->getProcedura()["fasi"] ?? null;
        if (!empty($fasi)) {
            foreach ($fasi as $id => $fase) {
                if ($fase["obbligatoria"]) {
                    if ($gara->inizializzaFase($id, $fase)) {
                        $error = false;
                        break;
                    }
                }
            }
        }

        $gara = $oggetto = null;
        $oggetto = gara::init($codice_gara);


        $elaborazione = [
            "settoreRiferimento" => $settoreRiferimento,
            "concessione" => NPA_Import::isConcessione($appalto->schedaPrincipale) ? "S" : "N"
        ];

        $oggetto->saveExtraInfo("elaborazione",json_encode($elaborazione, JSON_PRETTY_PRINT), "round");
        break;
    case 'concorsi':
        #TODO: scrivere la init Static del concorso;
        #$oggetto = concorso::initStatic();
        break;
    default:
        break;
}

// Importazione dei partecipanti
foreach ($appalto->lotti as $index => &$lotto) {

    if(NPA_Import::isDeserta($appalto->schede, $lotto)) {
        $oggetto->setLotto($lotto->codice_lotto_oggetto);
        $oggetto->updateStatoLotto(95);
        $oggetto->addToLog("DESERTA",__("Lotto") . " " .  $oggetto->lotto["numero"]);
        $oggetto->lotto = null;
    } else {
        // Importiamo i partecipanti
        $partecipanti = NPA_Import::importaPartecipanti($appalto->schede, $oggetto, $lotto);
        if (!empty($partecipanti)) {
            $hasPartecipanti = true;
        }
        if (NPA_Import::importaAggiudicatari($appalto->schede, $oggetto, $lotto, $partecipanti)) {
            $oggetto->setLotto($lotto->codice_lotto_oggetto);
            $oggetto->updateStatoLotto(35);
            $oggetto->lotto = null;
            $hasAggiudicatari = true;
        }
    }


    // Importiamo le schede di lotto
    NPA_Import::importaSchede($appalto->schede, $npa, $lotto);
}
// Importiamo le schede generali
NPA_Import::importaSchede($appalto->schede, $npa);


if ($hasAggiudicatari) {
    $oggetto->valutaStatoGenerale(true);
} elseif ($hasPartecipanti) {
    $oggetto->updateStato(21);
}

?>
<script>
    Swal({
        title: "Procedura importata con successo",
        html: "La procedura è stata importata con successo!",
        type: "success",
    }).then(() => {
        <?php if(!defined("__VERBOSE")): ?>
            window.location.reload();
        <?php endif; ?>
    })
</script>