<?php

declare(strict_types=1);
/**
 * Calendar App
 *
 * @copyright 2021 Anna Larch <anna.larch@gmx.net>
 *
 * @author Anna Larch <anna.larch@gmx.net>
 * @author Richard Steinmetz <richard@steinmetz.cloud>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU AFFERO GENERAL PUBLIC LICENSE for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

namespace OCA\Gestion\Service;

use DateTime;
use OCA\Gestion\Constants\BddConstant;
use OCA\Gestion\Constants\ClientTemplateTypeConstant;
use OCA\Gestion\Constants\DevisMentionConstant;
use OCA\Gestion\Constants\FactureTypeConstant;
use OCA\Gestion\Constants\MultipleFactureTypeConstant;
use OCA\Gestion\Db\Bdd;
use OCA\Gestion\Helpers\DateHelpers;
use OCA\Gestion\Service\InvoiceGroupPdfHandler\InvoiceFunecapPdfHandler;
use OCA\Gestion\Service\InvoiceGroupPdfHandler\InvoiceGroupPdfHandler;
use OCA\Gestion\Service\InvoiceGroupPdfHandler\InvoiceOgfPdfHandler;
use OCA\Gestion\Service\InvoiceRecap\InvoiceRecapService;
use OCP\DB\Exception;
use OCP\Files\IRootFolder;

class InvoicePdfService {
	/** @var Bdd */
	private $gestionBdd;

    /** @var IRootFolder */
	private $rootFolder;

    /** @var InvoiceRecapService */
	private $invoiceRecapService;

    private const DEFAULT_NEXTCLOUD_ADMIN = "admin";
	public function __construct(
		Bdd $gestionBdd,
        IRootFolder $rootFolder,
        InvoiceRecapService $invoiceRecapService) {
        $this->gestionBdd = $gestionBdd;
        $this->rootFolder = $rootFolder;
        $this->invoiceRecapService = $invoiceRecapService;
	}

    private function getLogo(){
        $storage = $this->rootFolder->getUserFolder(self::DEFAULT_NEXTCLOUD_ADMIN);
		try{
			try {
				if(isset($storage)){
					$file = $storage->get('/.gestion/logo.png');
				}else{
					return "nothing";
				}
			} catch(\OCP\Files\NotFoundException $e) {
				$file = $storage->get('/.gestion/logo.jpeg');
			}
		}
		catch(\OCP\Files\NotFoundException $e) {
			return "nothing";
		}

		return base64_encode($file->getContent());
	}

    private function generateFactureSinglePdfByFactureId($factureId,$idNextCloud){
        $storage = $this->rootFolder->getUserFolder($idNextCloud);
        $configs = json_decode($this->gestionBdd->getConfiguration(self::DEFAULT_NEXTCLOUD_ADMIN));
		$currentConfig = $configs[0];
		$logo = $this->getLogo();
		$invoicePdfData = $this->gestionBdd->getInvoicePdfData($factureId,$currentConfig);
		if($invoicePdfData == null){
			return null;
		}
        $clean_folder = html_entity_decode(string: $currentConfig->path).'/';
        $factureFolders = $this->getFacturesFolder($invoicePdfData,$clean_folder);
        $pdf = new InvoicePdfHandler();
        $pdf->AddFont('ComicSans','','Comic Sans MS.php');
        $pdf->AddFont('ComicSans','B','comic-sans-bold.php');
        $pdf->InvoicePdfFactory($invoicePdfData,$logo);
        $pdf->SetFactureContent();
        $pdfContent = $pdf->Output('','S');
        $pdfFilename = $pdf->GetInvoiceFilename();
        $filenames = [];
        foreach($factureFolders as $folder){
            try {
                $storage->newFolder($folder);
            } 
            catch(\OCP\Files\NotPermittedException $e) {
            }
            $ff_pdf = $folder.$pdfFilename.'.pdf';	
            $storage->newFile($ff_pdf);
            $file_pdf = $storage->get($ff_pdf);
            $file_pdf->putContent($pdfContent);
            $filenames[] = $ff_pdf;
        }
        $this->gestionBdd->setFactureGeneratedDate($factureId);
        return [
            "content" => $pdfContent,
            "filenames" => $filenames
        ];
    }

    public function generateFacturePdfByFactureId($factureId,$idNextCloud){
        $factureType = $this->gestionBdd->getFactureTypeByFactureId($factureId);
        if($factureType == FactureTypeConstant::TYPE_SINGLE){
            return $this->generateFactureSinglePdfByFactureId($factureId,$idNextCloud);
        }
        else{
            return $this->generateFactureGroupPdfByFactureId($factureId,$idNextCloud);
        }
    }

    private function getGroupFactureFolder(array $factureData,$racinePath){
        $clientRacineFolder = $racinePath.'CLIENTS/'.mb_strtoupper($factureData["group_name"],'UTF-8').'/';
        $factureDate = $factureData['date_paiement'];
        $factureDatetime = new DateTime($factureDate);
        $factureDateYear = $factureDatetime->format('Y');
        $factureMonth = DateHelpers::GetDateWithFormatDayAndMonthPlainString($factureData['date_paiement']);
        $factureByYearFolder = $clientRacineFolder."$factureDateYear".'/'.$factureMonth.'/'.'FACTURES'.'/';
        return [
            $factureByYearFolder
        ];
    }
    
    private function getFacturesFolder(array $factureData,$racinePath){
        $clientRacineFolder = $racinePath.'CLIENTS/'.mb_strtoupper($factureData["client_nom"],'UTF-8').'/';
        $defuntsFolder = $clientRacineFolder.'DEFUNTS/'.mb_strtoupper($factureData['defunt_nom'],'UTF-8').'/'.'FACTURES'.'/';
        $devisDate = $factureData['devis_date'];
        $devisDatetime = new DateTime($devisDate);
        $devisDateYear = $devisDatetime->format('Y');
        $devisMonth = DateHelpers::GetDateWithFormatDayAndMonthPlainString($factureData['devis_date']);
        $factureByYearFolder = $clientRacineFolder."$devisDateYear".'/'.$devisMonth.'/'.'FACTURES'.'/';
        return [
            $defuntsFolder,
            $factureByYearFolder
        ];
    }

    private function generateFactureGroupPdfByFactureId($factureId,$idNextCloud){
        $storage = $this->rootFolder->getUserFolder($idNextCloud);
        $configs = json_decode($this->gestionBdd->getConfiguration(self::DEFAULT_NEXTCLOUD_ADMIN));
		$currentConfig = $configs[0];
		$logo = $this->getLogo();
		$invoicePdfData = $this->gestionBdd->getInvoiceGroupPdfData($factureId,$currentConfig);
		if($invoicePdfData == null){
			return "";
		}
        $templateType = $invoicePdfData['template_type_key'];
        $clean_folder = html_entity_decode(string: $currentConfig->path).'/';
        $factureFolders = $this->getGroupFactureFolder($invoicePdfData,$clean_folder);

        switch ($templateType) {
            case ClientTemplateTypeConstant::FUNECAP:
                $pdf = new InvoiceFunecapPdfHandler();
                break;
            
            case ClientTemplateTypeConstant::OGF:
                $pdf = new InvoiceOgfPdfHandler();
                break;
        
            default:
                $pdf = new InvoiceGroupPdfHandler();
                break;
        }
        $pdf->AddFont('ComicSans','','Comic Sans MS.php');
        $pdf->AddFont('ComicSans','B','comic-sans-bold.php');
        $pdf->InvoicePdfFactory($invoicePdfData,$logo);
        $pdf->SetFactureContent();
        $pdfContent = $pdf->Output('','S');
        $pdfFilename = $pdf->GetInvoiceFilename();
        $filenames = [];
        foreach($factureFolders as $folder){
            try {
                $storage->newFolder($folder);
            } 
            catch(\OCP\Files\NotPermittedException $e) {
            }
            $ff_pdf = $folder.$pdfFilename.'.pdf';	
            $storage->newFile($ff_pdf);
            $file_pdf = $storage->get($ff_pdf);
            $file_pdf->putContent($pdfContent);
            $filenames[] = $ff_pdf;
        }
        $this->gestionBdd->setFactureGeneratedDate($factureId);
        return [
            "content" => $pdfContent,
            "filenames" => $filenames
        ];
    }

    public function generateFacturePdfByFactureIds(array $factureIds,$idNextCloud){
        foreach( $factureIds as $factureId ){
            $this->generateFacturePdfByFactureId($factureId,$idNextCloud);
        }
    }

    public function generateMultipleInvoicePdfByClientAndMonthYear($filter,$month,$year,$idNextCloud,$filterType){
        $storage = $this->rootFolder->getUserFolder($idNextCloud);
        $configs = json_decode($this->gestionBdd->getConfiguration(self::DEFAULT_NEXTCLOUD_ADMIN));
		$currentConfig = $configs[0];
        $logo = $this->getLogo();
        $invoiceData = $this->gestionBdd->getInvoicePdfDataByClientAndMonthYear($filter,$month,$year,$currentConfig,$filterType);
        if(empty($invoiceData)){
			return null;
		}
        $pdf = new InvoicePdfHandler();
        $pdf->AddFont('ComicSans','','Comic Sans MS.php');
        $pdf->AddFont('ComicSans','B','comic-sans-bold.php');
        $pdf->MutlipleInvoicePdfFactory($invoiceData,$logo);
        $pdf->SetMultipleFactureContent();
        $racinePath = html_entity_decode(string: $currentConfig->path).'/';
        $clientNameInFolder = $invoiceData[0]["client_nom"];
        if($invoiceData[0]['facture_type'] == MultipleFactureTypeConstant::GROUP_FILTER_TYPE){
            if($invoiceData[0]["group_name"] != null && $invoiceData[0]["group_name"] != ""){
                $clientNameInFolder = $invoiceData[0]["group_name"];
            }
        }
        $clientRacineFolder = $racinePath.'CLIENTS/'.mb_strtoupper($clientNameInFolder,'UTF-8').'/';
        $filename = "FACTURE".'_'.$pdf->GetMultipleInvoiceFilename($month,$year);
        $filenamePath = $clientRacineFolder.$filename.'.pdf';
        $pdfContent = $pdf->Output('','S');
        try {
            $storage->newFolder($clientRacineFolder);
        } 
        catch(\OCP\Files\NotPermittedException $e) {
        }	
        $storage->newFile($filenamePath);
        $file_pdf = $storage->get($filenamePath);
        $file_pdf->putContent($pdfContent);
        return $filenamePath;
    }

    public function generateInvoiceRecap($filter,$filterType,$date,$idNextCloud){
        $this->invoiceRecapService->generateInvoiceRecap($filter,$filterType,$date,$idNextCloud);
    }

    public function exportGroupOfDevisIntoFacture($clientId,$clientType,$month,$year,$facturationDate,$idNextcloud = BddConstant::DEFAULT_ADMIN_ID_NEXTCLOUD){
        try{
            $datetime = new Datetime();
            $month = $month ?? $datetime->format('m');
            $year = $year ?? $datetime->format('Y');
            
            $factureId = null;
            $fkClientId = null;
            $fkClientGroupFacturationId = null;
            $devisMentionFiltersToBeInvoiced = [
                DevisMentionConstant::NEW,
                DevisMentionConstant::MENTION
            ];
            if($clientType == MultipleFactureTypeConstant::CLIENT_FILTER_TYPE){
                $factureId = $this->gestionBdd->getFactureIdByClientIdAndMonthYear($clientId,$month,$year);
                $devisIds = $this->gestionBdd->getDevisIdsByClientIdAndMonthYear($clientId,$month,$year,$devisMentionFiltersToBeInvoiced); 
                $fkClientId = $clientId;
            }
            else{
                $factureId = $this->gestionBdd->getFactureIdByClientGroupFacturationIdAndMonthYear($clientId,$month,$year);
                $devisIds = $this->gestionBdd->getDevisIdsByClientGroupFacturationIdAndMonthYear($clientId,$month,$year);
                $fkClientGroupFacturationId = $clientId;
            }
            $clientIsAlreadyFacturedForThisMonthAndYear = $factureId != null && $factureId != 0;
            if($clientIsAlreadyFacturedForThisMonthAndYear == false){
                $factureId = $this->gestionBdd->createFactureAndReturnFactureId(
                    $facturationDate,
                    FactureTypeConstant::TYPE_GROUP,
                    $month,
                    $year,
                    $fkClientId,
                $fkClientGroupFacturationId);
            }
    
            $this->gestionBdd->invoiceListOfDevisIds($devisIds);
            $factureGeneratedResponse = $this->generateFactureGroupPdfByFactureId($factureId,$idNextcloud);
            return $factureGeneratedResponse["filenames"];
        }
        catch(Exception){
            return null;
        }
        
    }
}