<?php

require_once __DIR__ . '/../core/AbstractPdo.php';

class TypeDocumentDossierAdministratifService extends AbstractPdo
{
    protected $table = 'type_document_dossier_administratif';

    public function __construct()
    {
        parent::__construct();
    }

    /*   public function createTypeDocumentDossierAdministratif($data)
       {
           return $this->insert($data);
       }*/

    /**
     * Rechercher des typeDocumentDossierAdministratifs avec critères
     */
    public function search($searchData, $page = 1, $perPage = 10)
    {
        $filters = [];
        $searchFields = ['id', 'libelle', 'code', 'description'];

        foreach ($searchFields as $field) {
            if (!empty($searchData[$field])) {
                $filters[$field] = [
                    'value' => $searchData[$field],
                    'like' => true
                ];
            }
        }

        $offset = ($page - 1) * $perPage;
        $typeDocumentDossierAdministratifs = $this->findMultiple($filters, 'libelle ASC', $perPage, $offset);
        $total = $this->count($filters);

        return [
            'data' => $typeDocumentDossierAdministratifs,
            'total' => $total,
            'page' => $page,
            'perPage' => $perPage,
            'totalPages' => ceil($total / $perPage)
        ];
    }

    /**
     * Obtenir un typeDocumentDossierAdministratif par ID
     */
    public function getTypeDocumentDossierAdministratif($id)
    {
        return $this->findOne($id);
    }

    /**
     * Obtenir un typeDocumentDossierAdministratif par code
     */
    public function getTypeDocumentDossierAdministratifByCode($code)
    {
        return $this->findOneBy(['code' => $code]);
    }

    /**
     * Créer un nouveau typeDocumentDossierAdministratif
     */
    public function createTypeDocumentDossierAdministratif($data)
    {
        // Valider les données
        if (empty($data['libelle'])) {
            throw new Exception("Le libellé est obligatoire");
        }
        if (empty($data['code'])) {
            throw new Exception("Le code est obligatoire");
        }

        // Vérifier les doublons
        $this->checkDuplicates($data);

        return $this->insert($data);
    }

    /**
     * Mettre à jour un typeDocumentDossierAdministratif
     */
    public function updateTypeDocumentDossierAdministratif($id, $data)
    {
        // Vérifier si le typeDocumentDossierAdministratif existe
        $existing = $this->findOne($id);
        if (!$existing) {
            throw new Exception("TypeDocumentDossierAdministratif non trouvé");
        }

        // Vérifier les doublons (exclure l'ID actuel)
        $this->checkDuplicates($data, $id);

        return $this->update($id, $data);
    }

    /**
     * Vérifier les doublons
     */
    private function checkDuplicates($data, $excludeId = null)
    {
        $uniqueFields = ['code'];

        foreach ($uniqueFields as $field) {
            if (isset($data[$field]) && !empty($data[$field])) {
                $criteria = [$field => $data[$field]];
                $existing = $this->findOneBy($criteria);

                if ($existing && ($excludeId === null || $existing['id'] != $excludeId)) {
                    throw new Exception("Le champ '$field' est déjà utilisé par un autre typeDocumentDossierAdministratif");
                }
            }
        }
    }

    /**
     * Supprimer un typeDocumentDossierAdministratif
     */
    public function deleteTypeDocumentDossierAdministratif($id)
    {
        return $this->delete($id);
    }

    /**
     * Obtenir les statistiques
     */
    public function getStats()
    {
        $sql = "SELECT COUNT(*) as total FROM {$this->table}";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute();
        return $stmt->fetch();
    }

    /**
     * Exporter les typeDocumentDossierAdministratifs (CSV)
     */
    public function exportToCsv()
    {
        $typeDocumentDossierAdministratifs = $this->findAll('libelle ASC');

        if (empty($typeDocumentDossierAdministratifs)) {
            return null;
        }

        $csv = "ID,Libellé,Code,Description,Date de création,Date de mise à jour\n";
        foreach ($typeDocumentDossierAdministratifs as $g) {
            $csv .= implode(',', [
                    $g['id'],
                    '"' . addslashes($g['libelle']) . '"',
                    '"' . addslashes($g['code']) . '"',
                    '"' . addslashes($g['description'] ?? '') . '"',
                    $g['created_at'],
                    $g['updated_at'] ?? ''
                ]) . "\n";
        }

        return $csv;
    }

    /**
     * Importer des typeDocumentDossierAdministratifs (CSV)
     */
    public function importFromCsv($csvData)
    {
        $lines = explode("\n", trim($csvData));
        $headers = str_getcsv(array_shift($lines));

        $imported = 0;
        $errors = [];

        foreach ($lines as $line) {
            if (empty(trim($line))) continue;

            $data = array_combine($headers, str_getcsv($line));

            try {
                // Vérifier si le code existe déjà
                $existing = $this->findOneBy(['code' => $data['Code']]);
                if ($existing) {
                    // Mettre à jour
                    $this->update($existing['id'], [
                        'libelle' => $data['Libellé'],
                        'description' => $data['Description'] ?? null
                    ]);
                } else {
                    // Créer
                    $this->createTypeDocumentDossierAdministratif([
                        'libelle' => $data['Libellé'],
                        'code' => $data['Code'],
                        'description' => $data['Description'] ?? null
                    ]);
                }
                $imported++;
            } catch (Exception $e) {
                $errors[] = "Erreur ligne " . ($imported + 1) . ": " . $e->getMessage();
            }
        }

        return [
            'imported' => $imported,
            'errors' => $errors
        ];
    }

    /**
     * Obtenir tous les typeDocumentDossierAdministratifs (pour les selects)
     */
    public function getAllTypeDocumentDossierAdministratifs()
    {
        return $this->findAll('libelle ASC');
    }


}
