"""
DragonBank - Modele Transaction
=================================
Classe DAO gerant les virements et l'historique des transactions.

Chaque virement est atomique : debit et credit s'effectuent dans
la meme transaction SQL. Si l'une echoue, tout est annule.

Version : 3.0
"""

import decimal
import logging
import io
import csv

from flask import Response

from database import serialiser_ligne, serialiser_lignes
from config import LIMITE_TRANSACTIONS_DEFAUT, LIMITE_TRANSACTIONS_MAX

journaliseur = logging.getLogger('dragonbank.transaction')

# Noms lisibles pour les types de transactions (utilises dans l'export CSV).
NOMS_TYPES = {
    'virement_interne':         'Virement interne',
    'virement_entre_personnes': 'Virement entre personnes',
    'virement_externe':         'Virement externe',
    'depot':                    'Depot',
    'retrait':                  'Retrait',
    'interets':                 'Interets'
}


class TransactionDAO:
    """
    Objet d'acces aux donnees pour la table transactions.

    Contient la logique des trois types de virements :
      - Interne      : entre les propres comptes de l'utilisateur.
      - Entre personnes : vers un beneficiaire DragonBank.
      - Externe      : depuis/vers une banque tierce (simule).
    """

    # =========================================================
    # LECTURE
    # =========================================================

    def lister(self, connexion, id_utilisateur, id_compte=None,
               type_transaction=None, limite=None):
        """
        Retourne l'historique des transactions d'un utilisateur.

        Args:
            connexion           : Connexion PostgreSQL active.
            id_utilisateur      : UUID de l'utilisateur.
            id_compte (str)     : Filtrer par compte (optionnel).
            type_transaction    : Filtrer par type (optionnel).
            limite (int)        : Nombre max de resultats (defaut: 50).

        Returns:
            list[dict]: Transactions triees par date decroissante.
        """
        if limite is None:
            limite = LIMITE_TRANSACTIONS_DEFAUT
        if limite > LIMITE_TRANSACTIONS_MAX:
            limite = LIMITE_TRANSACTIONS_MAX

        requete_base = """
            SELECT t.id, t.from_account_id, t.to_account_id, t.transaction_type,
                   t.amount, t.currency, t.description, t.status, t.reference,
                   t.external_bank_name, t.external_account_number,
                   t.created_at, t.executed_at,
                   fa.account_number AS from_account_number,
                   ta.account_number AS to_account_number
            FROM transactions t
            LEFT JOIN accounts fa ON t.from_account_id = fa.id
            LEFT JOIN accounts ta ON t.to_account_id = ta.id
        """

        if id_compte:
            clause_where = "WHERE (t.from_account_id = %s OR t.to_account_id = %s)"
            parametres = [id_compte, id_compte]
        else:
            clause_where = "WHERE (fa.user_id = %s OR ta.user_id = %s)"
            parametres = [id_utilisateur, id_utilisateur]

        if type_transaction:
            clause_where = clause_where + " AND t.transaction_type = %s"
            parametres.append(type_transaction)

        parametres.append(limite)

        curseur = connexion.cursor()
        curseur.execute(
            requete_base + ' ' + clause_where + ' ORDER BY t.created_at DESC LIMIT %s',
            parametres
        )
        return serialiser_lignes(curseur.fetchall())

    def historique_solde(self, connexion, id_compte, solde_actuel):
        """
        Reconstitue l'evolution du solde d'un compte dans le temps.

        Utilise une back-calculation : on part du solde actuel
        et on remonte les transactions pour retrouver les soldes passes.

        Args:
            connexion      : Connexion PostgreSQL active.
            id_compte      : UUID du compte.
            solde_actuel   : Solde actuel du compte (float).

        Returns:
            list[dict]: Points {date, solde} en ordre chronologique.
        """
        curseur = connexion.cursor()
        curseur.execute(
            """
            SELECT created_at, amount, from_account_id, to_account_id
            FROM transactions
            WHERE (from_account_id = %s OR to_account_id = %s)
              AND status = 'completed'
            ORDER BY created_at DESC
            """,
            (id_compte, id_compte)
        )
        transactions = curseur.fetchall()

        solde_courant = float(solde_actuel)
        points = []

        for transaction in transactions:
            montant   = float(transaction['amount'])
            est_debit = str(transaction['from_account_id']) == id_compte

            points.append({
                'date':  str(transaction['created_at'])[:10],
                'solde': round(solde_courant, 2)
            })

            if est_debit:
                solde_courant = solde_courant + montant
            else:
                solde_courant = solde_courant - montant

        points.append({'date': 'Ouverture', 'solde': round(solde_courant, 2)})
        points.reverse()
        return points

    # =========================================================
    # VIREMENTS
    # =========================================================

    def virement_interne(self, connexion, id_source, id_destination,
                         montant, libelle, compte_dao):
        """
        Effectue un virement entre deux comptes du meme utilisateur.

        Verifie le solde puis debite la source et credite la destination
        dans la meme transaction SQL (atomicite).

        Args:
            connexion       : Connexion PostgreSQL active.
            id_source (str) : UUID du compte source.
            id_destination  : UUID du compte destination.
            montant         : Montant (Decimal).
            libelle (str)   : Description du virement.
            compte_dao      : Instance de CompteDAO pour les mises a jour.

        Returns:
            dict: La transaction creee.

        Raises:
            ValueError: Si le solde est insuffisant.
        """
        self._verifier_solde_suffisant(connexion, id_source, montant)

        compte_dao.debiter(connexion, id_source, montant)
        compte_dao.crediter(connexion, id_destination, montant)

        return self._enregistrer(
            connexion,
            from_id=id_source,
            to_id=id_destination,
            type_t='virement_interne',
            montant=montant,
            libelle=libelle
        )

    def virement_entre_personnes(self, connexion, id_source, id_destination,
                                  montant, libelle, compte_dao):
        """
        Effectue un virement vers un beneficiaire DragonBank.

        Args:
            connexion       : Connexion PostgreSQL active.
            id_source (str) : UUID du compte source.
            id_destination  : UUID du compte destination (beneficiaire).
            montant         : Montant (Decimal).
            libelle (str)   : Description du virement.
            compte_dao      : Instance de CompteDAO.

        Returns:
            dict: La transaction creee.

        Raises:
            ValueError: Si le solde est insuffisant.
        """
        self._verifier_solde_suffisant(connexion, id_source, montant)

        compte_dao.debiter(connexion, id_source, montant)
        compte_dao.crediter(connexion, id_destination, montant)

        return self._enregistrer(
            connexion,
            from_id=id_source,
            to_id=id_destination,
            type_t='virement_entre_personnes',
            montant=montant,
            libelle=libelle
        )

    def virement_externe(self, connexion, id_compte, montant, direction,
                          nom_banque, numero_externe, libelle, compte_dao):
        """
        Simule un virement depuis ou vers une banque externe.

        Args:
            connexion       : Connexion PostgreSQL active.
            id_compte (str) : UUID du compte DragonBank.
            montant         : Montant (Decimal).
            direction (str) : 'outgoing' ou 'incoming'.
            nom_banque (str): Nom de la banque externe.
            numero_externe  : Numero de compte externe.
            libelle (str)   : Description.
            compte_dao      : Instance de CompteDAO.

        Returns:
            dict: La transaction creee.

        Raises:
            ValueError: Si le solde est insuffisant (direction outgoing).
        """
        if direction == 'outgoing':
            self._verifier_solde_suffisant(connexion, id_compte, montant)
            compte_dao.debiter(connexion, id_compte, montant)
            from_id = id_compte
            to_id   = None
        else:
            compte_dao.crediter(connexion, id_compte, montant)
            from_id = None
            to_id   = id_compte

        return self._enregistrer(
            connexion,
            from_id=from_id,
            to_id=to_id,
            type_t='virement_externe',
            montant=montant,
            libelle=libelle,
            banque_externe=nom_banque,
            numero_externe=numero_externe
        )

    # =========================================================
    # EXPORT CSV
    # =========================================================

    def exporter_csv(self, connexion, id_utilisateur, id_compte=None):
        """
        Genere un fichier CSV de l'historique des transactions.

        Le fichier est encode en UTF-8 avec BOM (utf-8-sig) pour
        une compatibilite optimale avec Microsoft Excel sous Windows.
        Le separateur est le point-virgule (standard europeen).

        Args:
            connexion       : Connexion PostgreSQL active.
            id_utilisateur  : UUID de l'utilisateur.
            id_compte (str) : Restreindre a un compte (optionnel).

        Returns:
            flask.Response: Reponse HTTP avec le fichier CSV en piece jointe.
        """
        if id_compte:
            curseur = connexion.cursor()
            curseur.execute(
                """
                SELECT t.created_at, t.transaction_type, t.description,
                       t.amount, t.status,
                       fa.account_number AS from_account,
                       ta.account_number AS to_account,
                       t.external_bank_name
                FROM transactions t
                LEFT JOIN accounts fa ON t.from_account_id = fa.id
                LEFT JOIN accounts ta ON t.to_account_id = ta.id
                WHERE (t.from_account_id = %s OR t.to_account_id = %s)
                ORDER BY t.created_at DESC
                """,
                (id_compte, id_compte)
            )
        else:
            curseur = connexion.cursor()
            curseur.execute(
                """
                SELECT t.created_at, t.transaction_type, t.description,
                       t.amount, t.status,
                       fa.account_number AS from_account,
                       ta.account_number AS to_account,
                       t.external_bank_name
                FROM transactions t
                LEFT JOIN accounts fa ON t.from_account_id = fa.id
                LEFT JOIN accounts ta ON t.to_account_id = ta.id
                WHERE (fa.user_id = %s OR ta.user_id = %s)
                ORDER BY t.created_at DESC
                """,
                (id_utilisateur, id_utilisateur)
            )

        lignes = curseur.fetchall()

        sortie  = io.StringIO()
        writer  = csv.writer(sortie, delimiter=';', quoting=csv.QUOTE_ALL)

        writer.writerow([
            'Date', 'Type', 'Libelle', 'Montant (EUR)',
            'Statut', 'Compte source', 'Compte destination', 'Banque externe'
        ])

        for ligne in lignes:
            date = str(ligne['created_at'])[:16].replace('T', ' ') if ligne['created_at'] else ''
            writer.writerow([
                date,
                NOMS_TYPES.get(ligne['transaction_type'], ligne['transaction_type']),
                ligne['description'] or '',
                '{:.2f}'.format(float(ligne['amount'])),
                ligne['status'] or '',
                ligne['from_account'] or '',
                ligne['to_account'] or '',
                ligne['external_bank_name'] or ''
            ])

        contenu = sortie.getvalue()
        sortie.close()

        return Response(
            contenu.encode('utf-8-sig'),
            mimetype='text/csv',
            headers={
                'Content-Disposition': 'attachment; filename="dragonbank_transactions.csv"',
                'Content-Type': 'text/csv; charset=utf-8'
            }
        )

    # =========================================================
    # STATISTIQUES
    # =========================================================

    def statistiques(self, connexion, id_utilisateur):
        """
        Calcule les statistiques de transactions du mois courant.

        Args:
            connexion       : Connexion PostgreSQL active.
            id_utilisateur  : UUID de l'utilisateur.

        Returns:
            dict: {transactions_mois, total_envoye, total_recu}
        """
        curseur = connexion.cursor()
        curseur.execute(
            """
            SELECT COUNT(*) AS transactions_mois,
                   COALESCE(SUM(CASE WHEN fa.user_id = %s THEN t.amount ELSE 0 END), 0) AS total_envoye,
                   COALESCE(SUM(CASE WHEN ta.user_id = %s THEN t.amount ELSE 0 END), 0) AS total_recu
            FROM transactions t
            LEFT JOIN accounts fa ON t.from_account_id = fa.id
            LEFT JOIN accounts ta ON t.to_account_id = ta.id
            WHERE (fa.user_id = %s OR ta.user_id = %s)
              AND t.created_at >= date_trunc('month', CURRENT_DATE)
              AND t.status = 'completed'
            """,
            (id_utilisateur, id_utilisateur, id_utilisateur, id_utilisateur)
        )
        return curseur.fetchone()

    # =========================================================
    # UTILITAIRES PRIVES
    # =========================================================

    def _verifier_solde_suffisant(self, connexion, id_compte, montant):
        """
        Verifie que le solde du compte est suffisant pour le debit.

        Args:
            connexion  : Connexion PostgreSQL active.
            id_compte  : UUID du compte a verifier.
            montant    : Montant a debiter (Decimal).

        Raises:
            ValueError: Si le solde est inferieur au montant.
        """
        curseur = connexion.cursor()
        curseur.execute('SELECT balance FROM accounts WHERE id = %s', (id_compte,))
        resultat = curseur.fetchone()
        if resultat is None:
            raise ValueError("Compte introuvable")

        solde = decimal.Decimal(str(resultat['balance']))
        if solde < montant:
            raise ValueError(
                "Solde insuffisant (disponible : "
                + '{:.2f}'.format(float(solde)) + " euros)"
            )

    def _enregistrer(self, connexion, from_id, to_id, type_t,
                      montant, libelle, banque_externe=None, numero_externe=None):
        """
        Insere une nouvelle transaction en base de donnees.

        Args:
            connexion        : Connexion PostgreSQL active.
            from_id          : UUID du compte source (ou None).
            to_id            : UUID du compte destination (ou None).
            type_t (str)     : Type de transaction.
            montant          : Montant (Decimal ou float).
            libelle (str)    : Description.
            banque_externe   : Nom de la banque externe (optionnel).
            numero_externe   : Numero de compte externe (optionnel).

        Returns:
            dict: La transaction inseree.
        """
        curseur = connexion.cursor()
        curseur.execute(
            """
            INSERT INTO transactions
                (from_account_id, to_account_id, transaction_type, amount,
                 description, status, external_bank_name,
                 external_account_number, executed_at)
            VALUES (%s, %s, %s, %s, %s, 'completed', %s, %s, NOW())
            RETURNING id, amount, description, status, created_at
            """,
            (from_id, to_id, type_t, float(montant),
             libelle, banque_externe, numero_externe)
        )
        return serialiser_ligne(curseur.fetchone())