<?php

class File {

    public static function GetValidName($oldName) {
        $newName = "";
        $name = $oldName;
        for ($i = 0; $i < strlen($name); $i++) {
            $char = substr($name, $i, 1);
            if (!preg_match("/^[a-zA-Z0-9]$/", $char)) {
                $char = "_";
            }
            $newName .= $char;
        }
        return $newName;
    }

    /**
     * 
     * @param type $oldName
     * @param type $newExt
     * @param type $arrayExt estensioni da controllare di secondo livello nel filename es: array('.pdf','.doc','.zip')
     * @return type
     */
    public static function GetValidFilename($oldName, $newExt = "", $arrayExt = array('.pdf')) {
        $newName = "";
        $name = $oldName;
        $ext = self::GetFilenameExtension($name);
        if ($ext != "") {
            $name = substr($name, 0, strlen($name) - strlen($ext));
            $ext2 = self::GetFilenameExtension($name);
            if (in_array($ext2, $arrayExt)) {
                $name = substr($name, 0, strlen($name) - strlen($ext2));
                $ext = $ext2 . $ext;
            }
        }
        for ($i = 0; $i < strlen($name); $i++) {
            $char = substr($name, $i, 1);
            if (!preg_match("/^[a-zA-Z0-9-]$/", $char)) {
                $char = "_";
            }
            $newName .= $char;
        }
        $newName = str_replace(" ", "_", $newName);
        $newName .= ($newExt != "" ? $newExt : $ext);
        return $newName;
    }

    public static function GetFilenameExtension($filename) {
        $i = strrpos($filename, ".");
        if ($i === false) {
            return "";
        }
        return substr($filename, $i);
    }

    public static function CheckValidityExtension($estensione) {
        if ($estensione == "p7m") {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Verifico se il certificato del file firmato p7m è valido e se il codice fiscale del firmatario corrisponde al codice fiscale dell'utente loggato o del codice fiscale passato per riferimento
     * @global type $LoggedAccount
     * @param type $leggoCertificato
     * @param type $codicefiscale
     * @return string
     */
    public static function verifyCertificato($leggoCertificato, $codicefiscale = '') {
        global $LoggedAccount, $CODICI_ERRORE_UPLOAD_P7M;
        if (!DISABLED_SIGNED_CONTROL) {
            $return = Utils::initDefaultResponse();
            $cfiscaleFirmatario = ($codicefiscale != "" ? $codicefiscale : $LoggedAccount->CODICE_FISCALE);
            $cerco = Utils::tag_contents($leggoCertificato, "-----BEGIN CERTIFICATE-----", "-----END CERTIFICATE-----");
            foreach ($cerco as $scorrolefirme) {
                $datiCertificatoSearch = openssl_x509_parse("-----BEGIN CERTIFICATE-----\n" . trim($scorrolefirme) . "\n-----END CERTIFICATE-----");
                //echo self::extractCf($datiCertificatoSearch['subject']['serialNumber']); exit();
                if ($cfiscaleFirmatario == self::extractCf($datiCertificatoSearch['subject']['serialNumber'])) {
                    $verifyValidCertificateDate = self::verifyValidCertificateDate($datiCertificatoSearch['validFrom_time_t'], $datiCertificatoSearch['validTo_time_t']);
                    if ($verifyValidCertificateDate['esito'] == 1) {
                        $return['esito'] = 1;
                        $return['erroreDescrizione'] = "";
                    } else {
                        $return = $verifyValidCertificateDate;
                    }
                    return $return;
                } else {
                    $return['esito'] = 202079;
                    $return['erroreDescrizione'] = $CODICI_ERRORE_UPLOAD_P7M[202079];
                }
            }
        } else {
            $return = Utils::initDefaultResponse(1, '');
        }

        return $return;
    }

    /**
     * Verifica la scadenza del certificato p7m
     * @param type $validFrom
     * @param type $validTo
     * @return string
     */
    public static function verifyValidCertificateDate($validFrom, $validTo) {
        global $CODICI_ERRORE_UPLOAD_P7M;
        $dataAttuale = time();
        $return = Utils::initDefaultResponse();
        if ($dataAttuale >= $validFrom && $dataAttuale <= $validTo) {
            $return['esito'] = 1;
            $return['erroreDescrizione'] = "";
        } else {
            $return['esito'] = 2020100;
            $return['erroreDescrizione'] = $CODICI_ERRORE_UPLOAD_P7M[2020100];
        }
        return $return;
    }

    public static function verifyCertificatoRevisore($datiCertificato = "") {
        global $LoggedAccount;
        $dataAttuale = time();
        $validFrom = $datiCertificato['validFrom_time_t'];
        $validTo = $datiCertificato['validTo_time_t'];
        if ($dataAttuale >= $validFrom && $dataAttuale <= $validTo) {
            $return['esito'] = 1;
        } else {
            $return['esito'] = -999;
            $return['erroreDescrizione'] = "Certificato di firma digitale scaduto";
        }
        return $return;
    }

    /**
     * Estrai li codice fiscale dal tag del certificato p7m
     * @param type $codice_fiscale
     * @return type
     */
    public static function extractCf($codice_fiscale) {
        $cfrevisitedexplode = explode("-", $codice_fiscale);
        if ($cfrevisitedexplode[1] == "") {
            $cfrevisitedexplode = explode(":", $codice_fiscale);
            $cfrevisited = $cfrevisitedexplode[1];
        } else {
            $cfrevisited = $cfrevisitedexplode[1];
        }
        return $cfrevisited;
    }

    /**
     * Funzioni controllo file
     */
    /*     * *********************************** TEST GIGI ************************************************** */
    public static function checkFileAllegato($uploadedName = '', $max_file_size = MAX_SIZE_FILE_UPLOAD, $format = 'p7m') {
        $response = Utils::initDefaultResponse();
        if ($uploadedName != '') {
            if (intval($_FILES[$uploadedName]['size']) <= 0) {
                $response['erroreDescrizione'] = "Dimensione file non consistente";
            } else if (intval($_FILES[$uploadedName]['size']) > $max_file_size) {
                $response['erroreDescrizione'] = "Dimensione file non consentita";
            } else if ($_FILES[$uploadedName]['tmp_name'] == "") {
                $response['erroreDescrizione'] = "Nessun file allegato";
            } else {
                $ext = self::extractExtensionFromFile($uploadedName);
                if (empty($ext) || $ext != $format) {
                    $response['erroreDescrizione'] = "Formato del file non valido!";
                } else {
                    $mymeType = self::extractMimeTypeFromFile($_FILES[$uploadedName]['tmp_name']);
                    if (ATTIVA_CONTROLLO_MIME_TYPE && $mymeType != MIME_TYPE) {
                        $response['erroreDescrizione'] = "Formato del file non valido!";
                    } else {
                        $response['esito'] = 1;
                        $response['filesize'] = intval($_FILES[$uploadedName]['size']);
                        $response['name'] = $_FILES[$uploadedName]['name'];
                    }
                }
            }
        }
        return $response;
    }

    /**
     * Verifico se le dimensioni e MD5 del file temporaneo sono uguali al file copiato
     * @param type $tmp_name
     * @param type $filePath
     * @return type
     */
    public static function checkMd5File($tmp_name = '', $filePath = '') {
        $response = false;
        if ($tmp_name != '' && $filePath != '') {
            $response = (filesize($tmp_name) == filesize($filePath) && md5_file($tmp_name) == md5_file($filePath));
        }
        return $response;
    }

    public static function getSha256File($tmp_name = '') {
        $response = "";
        if ($tmp_name != '') {
            $response = hash_file('sha256', $tmp_name);
        }
        return $response;
    }

    public static function checkFileConsistency($filePath = '') {
        $response = false;
        if ($filePath != '') {
            $response = (file_exists($filePath) && filesize($filePath) > 0);
        }
        return $response;
    }

    public static function extractMimeTypeFromFile($uploadedFile = '') {
        $response = "";
        $finfo = finfo_open(FILEINFO_MIME_TYPE);
        $response = finfo_file($finfo, $uploadedFile);
        finfo_close($finfo);
        return strtolower($response);
    }

    public static function extractExtensionFromFile($uploadedName = '') {
        $response = "";
        if ($uploadedName != '' && isset($_FILES[$uploadedName]) && !empty($_FILES[$uploadedName]['name'])) {
            $ricavoExt = $_FILES[$uploadedName]['name'];
            $file = pathinfo($_FILES[$uploadedName]['name']);
            $response = strtolower($file['extension']);
        }
        return $response;
    }

    public static function getValidFilenameFromFile($uploadedName = '') {
        $response = "";
        if ($uploadedName != "" && isset($_FILES[$uploadedName])) {
            $response = self::GetValidFilename($_FILES[$uploadedName]['name']);
        }
        return $response;
    }

    public static function getFolderFromDomanda($domanda = null, $root_upload = '') {
        global $LoggedAccount;
        $folder = '';
        if (!empty($domanda) && !empty($domanda->ID) && !empty($domanda->ID_ACCOUNT) && !empty($root_upload) && !empty($LoggedAccount->CODICE_FISCALE)) {
            $folder = $root_upload . $domanda->ID . "_" . $LoggedAccount->CODICE_FISCALE;
        }
        return $folder;
    }
    
    public static function getFolderFromDomandaOld($id_domanda, $root_upload = '') {
        global $LoggedAccount;
        $folder = '';
        if ($id_domanda>0 && !empty($root_upload) && !empty($LoggedAccount->CODICE_FISCALE)) {
            $folder = $root_upload . $id_domanda . "_" . $LoggedAccount->CODICE_FISCALE;
        }
        return $folder;
    }

    /*     * *********************************************************************************** */

    public static function maxDimension($dimensione = "", $max_file_size = 0) {
        return ($dimensione > $max_file_size ? true : false );
    }

    public static function checkTmpName($name = "") {
        $response = false;
        if ($name != "") {
            $response = ($_FILES[$name]['tmp_name'] == "" ? true : false);
        }
        return $response;
    }

    public static function extensionFile($tipo_file = "", $estenzione_file = "p7m") {
        return ($tipo_file != $estenzione_file ? true : false );
    }

    public static function md5NameFile($nomeFile = "") {
        return ($nomeFile == "" ? "" : md5($nomeFile) );
    }

    public static function createPath($path = "") {
        if (is_dir($path) === false) {
            mkdir($path, 0755, true);
        }
        if (is_dir($path) === false) { // controllo se la cartella è stata creata
            $path = '';
        }
        return $path;
    }

    public static function checkCertificatoP7m($fileSource = '', $fileDest = '', $fileDestPem = '', $codicefiscale = '', $hashfile = '') {
        global $CODICI_ERRORE_UPLOAD_P7M;
        $response = Utils::initDefaultResponse();

        $fileSourceTMPbase64 = self::setFileNamep7mTMP($fileSource);
        self::shellExecBase64($fileSource, $fileSourceTMPbase64);

        if (filesize($fileSourceTMPbase64) > 0) {
            $fileSource = $fileSourceTMPbase64;
        } else {
            unlink($fileSourceTMPbase64);
        }


        self::shellExecCms($fileSource, $fileDest);
        $hashestratto = self::md5File($fileDest);
        if (filesize($fileDest) > 0) {
            if ($hashestratto == $hashfile || DISABLED_HASH_CONTROL) {
                self::shellExecPkcs7($fileSource, $fileDestPem);
                if (filesize($fileDestPem) > 0) {
                    self::shellExecX509($fileDestPem);
                    $leggoCertificato = file_get_contents($fileDestPem);
                    $response = self::verifyCertificato($leggoCertificato, $codicefiscale);
                    if ($response['esito'] == 1) {
                        if (filesize($fileSourceTMPbase64) > 0) {
                            unlink($fileSourceTMPbase64);
                        }
                    }
                } else {
                    $response['esito'] = 2020276;
                    $response['erroreDescrizione'] = $CODICI_ERRORE_UPLOAD_P7M[2020276];
                }
            } else {
                $response['esito'] = 2020280;
                $response['erroreDescrizione'] = $CODICI_ERRORE_UPLOAD_P7M[2020280];
            }
        } else {
            $response['esito'] = 2020277;
            $response['erroreDescrizione'] = $CODICI_ERRORE_UPLOAD_P7M[2020277]; // . ($fileDest);
        }
        return $response;
    }

    /**
     * crea il nome del file temporaneo p7m per utilizzarlo nella decodifica in base64
     * @param type $fileSource
     * @return type
     */
    public static function setFileNamep7mTMP($fileSource = '') {
        $file = pathinfo($fileSource);
        return $file['dirname'] . '/FILETMP_' . $file['basename'];
    }

    public static function extractPemFromP7m() {
        
    }

    public static function shellExecCms($file = "", $fileEstratto = "") {
        return shell_exec('openssl cms -verify -noverify -in ' . $file . ' -inform DER -out ' . $fileEstratto);
    }

    public static function shellExecPkcs7($file = "", $fileEstrattoPem = "") {
        return shell_exec('openssl pkcs7 -inform DER -in ' . $file . ' -print_certs -out ' . $fileEstrattoPem);
    }

    public static function shellExecX509($fileEstrattoPem = "") {
        return shell_exec('openssl x509 -in ' . $fileEstrattoPem . ' -text -noout');
    }

    public static function md5File($nomeFile = 0) {
        return md5_file($nomeFile);
    }

    public static function shellExecBase64($file = "", $fileDest = "") {
        return shell_exec('base64 -d ' . $file . ' > ' . $fileDest);
        //return shell_exec('openssl base64 -d -in '.$file.' -out '.$fileDest);
    }

    /**
     * in caso di errore viene fatta una copia del file p7m che ha generato l'errore e viene salvato tutto nell'apposita tabella di logs
     * @param type $fileName
     * @param type $domanda
     * @param type $fileFullPath
     * @param string $fileFullPathLogsp7m
     * @param type $errore
     * @param type $fase
     * @return type
     */
    public static function copyFileandSaveLogs($fileName = "", $domanda = null, $fileFullPath = "", $fileFullPathLogsp7m = "", $errore = "", $fase = DOCUMENTI_FASE_1) {
        $response = Utils::initDefaultResponse();
        if (!empty($fileFullPath) && !empty($fileFullPathLogsp7m) && !empty($domanda) && !empty($fileName)) {

            $folderLOGSP7M = $domanda->generateDirForUpload(ROOT_UPLOAD_PRESENTAZIONE, ROOT_UPLOAD_PRESENTAZIONE_LOGS_P7M);
            $fileFullPathLogsp7m = $folderLOGSP7M . "/" . $fileName;
            if ($folderLOGSP7M) {
                copy($fileFullPath, $fileFullPathLogsp7m);
                $logUploadP7m = new LogsP7mFile();
                $logUploadP7m->ID_DOMANDA = $domanda->ID;
                $logUploadP7m->ERRORE = $errore;
                $logUploadP7m->FILEPATH = $fileFullPathLogsp7m;
                $logUploadP7m->FASE = $fase;
                $response = $logUploadP7m->Save();
            } else {
                $response['erroreDescrizione'] = "Al momento non è possibile allegare il file, contattare un amministratore!";
            }
        }
        return $response;
    }

    public static function deleteFileTemp($fileFullPath = '', $fileFullPathEstratto = '', $fileFullPathEstrattoPem = '') {

        if (!empty($fileFullPath)) {
            unlink($fileFullPath);
        }
        if (!empty($fileFullPathEstratto)) {
            unlink($fileFullPathEstratto);
        }
        if (!empty($fileFullPathEstrattoPem)) {
            unlink($fileFullPathEstrattoPem);
        }
    }
}