# -*- mode: python -*-
# -*- coding: utf-8 -*-

##############################################################################
#
# Gestion scolarite IUT
#
# Copyright (c) 1999 - 2023 Emmanuel Viennet.  All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#   Emmanuel Viennet      emmanuel.viennet@viennet.net
#
##############################################################################

from __future__ import annotations

from openpyxl.cell import WriteOnlyCell
from openpyxl.worksheet.worksheet import Worksheet

from app.but.prepajury_xl_format import Sco_Style

""" Excel file handling
"""
import datetime
from tempfile import NamedTemporaryFile

import openpyxl.utils.datetime
from openpyxl.styles.numbers import FORMAT_DATE_DDMMYY
from openpyxl.comments import Comment
from openpyxl import Workbook


import app.scodoc.sco_utils as scu
from app.scodoc.sco_exceptions import ScoValueError


# Un style est enregistré comme un dictionnaire qui précise la valeur d'un attribut dans la liste suivante:
# font, border, number_format, fill,...
# (cf https://openpyxl.readthedocs.io/en/stable/styles.html#working-with-styles)


def xldate_as_datetime(xldate, datemode=0):
    """Conversion d'une date Excel en datetime python
    Deux formats de chaîne acceptés:
     * JJ/MM/YYYY (chaîne naïve)
     * Date ISO (valeur de type date lue dans la feuille)
    Peut lever une ValueError
    """
    try:
        return datetime.datetime.strptime(xldate, "%d/%m/%Y")
    except:
        return openpyxl.utils.datetime.from_ISO8601(xldate)


def adjust_sheetname(sheet_name):
    """Renvoie un nom convenable pour une feuille excel: < 31 cars, sans caractères spéciaux
    Le / n'est pas autorisé par exemple.
    Voir https://xlsxwriter.readthedocs.io/workbook.html#add_worksheet
    """
    sheet_name = scu.make_filename(sheet_name)
    # Le nom de la feuille ne peut faire plus de 31 caractères.
    # si la taille du nom de feuille est > 31 on tronque (on pourrait remplacer par 'feuille' ?)
    return sheet_name[:31]


class ScoExcelBook:
    """Permet la génération d'un classeur xlsx composé de plusieurs feuilles.
    usage:
        wb = ScoExcelBook()
        ws0 = wb.create_sheet('sheet name 0')
        ws1 = wb.create_sheet('sheet name 1')
        ...
        steam = wb.generate()
    """

    def __init__(self):
        self.sheets = []  # list of sheets
        self.wb = Workbook()

    def create_sheet(self, sheet_name="feuille", default_style=None):
        """Crée une nouvelle feuille dans ce classeur
        sheet_name -- le nom de la feuille
        default_style -- le style par défaut
        """
        sheet_name = adjust_sheetname(sheet_name)
        ws = self.wb.create_sheet(sheet_name)
        sheet = ScoExcelSheet(sheet_name, default_style, ws)
        self.sheets.append(sheet)
        return sheet

    def generate(self):
        """génération d'un stream binaire représentant la totalité du classeur.
        retourne le flux
        """
        sheet: Worksheet = self.wb.get_sheet_by_name("Sheet")
        self.wb.remove_sheet(sheet)

        for sheet in self.sheets:
            sheet.prepare()
        # construction d'un flux
        # (https://openpyxl.readthedocs.io/en/stable/tutorial.html#saving-as-a-stream)
        with NamedTemporaryFile() as tmp:
            self.wb.save(tmp.name)
            tmp.seek(0)
            return tmp.read()


class ScoExcelSheet:
    """Représente une feuille qui peut être indépendante ou intégrée dans un ScoExcelBook.
    En application des directives de la bibliothèque sur l'écriture optimisée, l'ordre des opérations
    est imposé:
    * instructions globales (largeur/maquage des colonnes et ligne, ...)
    * construction et ajout des cellules et ligne selon le sens de lecture (occidental)
    ligne de haut en bas et cellules de gauche à droite (i.e. A1, A2, .. B1, B2, ..)
    * pour finir appel de la méthode de génération
    """

    def __init__(self, sheet_name="feuille", default_style=None, wb: Workbook = None):
        """Création de la feuille. sheet_name
        -- le nom de la feuille default_style
        -- le style par défaut des cellules ws
        -- None si la feuille est autonome (dans ce cas elle crée son propre wb), sinon c'est la worksheet
        créée par le workbook propriétaire un workbook est créé et associé à cette feuille.
        """
        # Le nom de la feuille ne peut faire plus de 31 caractères.
        # si la taille du nom de feuille est > 31 on tronque (on pourrait remplacer par 'feuille' ?)
        self.sheet_name = adjust_sheetname(sheet_name)
        self.default_style = default_style or Sco_Style()
        if wb is None:
            self.wb = Workbook()
            self.ws = self.wb.active
            self.ws.title = self.sheet_name
        else:
            self.wb = None
            self.ws = wb
        # internal data
        self.rows = []  # list of list of cells
        self.column_dimensions = {}
        self.row_dimensions = {}

    @staticmethod
    def i2col(idx):
        if idx < 26:  # one letter key
            return chr(idx + 65)
        else:  # two letters AA..ZZ
            first = (idx // 26) + 66
            second = (idx % 26) + 65
            return "" + chr(first) + chr(second)

    def set_column_dimension_width(self, cle=None, value=21):
        """Détermine la largeur d'une colonne. cle -- identifie la colonne ("A" "B", ... ou 0, 1, 2, ...) si None,
        value donne la liste des largeurs de colonnes depuis A, B, C, ... value -- la dimension (unité : 7 pixels
        comme affiché dans Excel)
        """
        if cle is None:
            for i, val in enumerate(value):
                self.ws.column_dimensions[self.i2col(i)].width = val
            # No keys: value is a list of widths
        elif isinstance(cle, str):  # accepts set_column_with("D", ...)
            self.ws.column_dimensions[cle].width = value
        else:
            self.ws.column_dimensions[self.i2col(cle)].width = value

    def set_row_dimension_height(self, cle=None, value=21):
        """Détermine la hauteur d'une ligne. cle -- identifie la ligne (1, 2, ...) si None,
        value donne la liste des hauteurs de colonnes depuis 1, 2, 3, ... value -- la dimension
        """
        if cle is None:
            for i, val in enumerate(value, start=1):
                self.ws.row_dimensions[i].height = val
            # No keys: value is a list of widths
        else:
            self.ws.row_dimensions[cle].height = value

    def set_row_dimension_hidden(self, cle, value):
        """Masque ou affiche une ligne.
        cle -- identifie la colonne (1...)
        value -- boolean (vrai = colonne cachée)
        """
        self.ws.row_dimensions[cle].hidden = value

    def make_cell(self, value: any = None, style: Sco_Style = None, comment=None):
        """Construit une cellule.
        value -- contenu de la cellule (texte, numérique, booléen ou date)
        style -- style par défaut (dictionnaire cf. excel_make_style) de la feuille si non spécifié
        """
        # adaptation des valeurs si nécessaire
        if value is None:
            value = ""
        elif value is True:
            value = 1
        elif value is False:
            value = 0
        elif isinstance(value, datetime.datetime):
            value = value.replace(
                tzinfo=None
            )  # make date naive (cf https://openpyxl.readthedocs.io/en/latest/datetime.html#timezones)

        # création de la cellule
        cell = WriteOnlyCell(self.ws, value)

        if style is not None:
            style.apply(cell)

        if not comment is None:
            cell.comment = Comment(comment, "scodoc")
            lines = comment.splitlines()
            cell.comment.width = 7 * max([len(line) for line in lines]) if lines else 7
            cell.comment.height = 20 * len(lines) if lines else 20

        # test datatype to overwrite datetime format
        if isinstance(value, datetime.date):
            cell.data_type = "d"
            cell.number_format = FORMAT_DATE_DDMMYY
        elif isinstance(value, int) or isinstance(value, float):
            cell.data_type = "n"
        else:
            cell.data_type = "s"

        return cell

    def make_row(self, values: list, style=None, comments=None) -> list:
        "build a row"
        # TODO make possible differents styles in a row
        if comments is None:
            comments = [None] * len(values)
        return [
            self.make_cell(value, style, comment)
            for value, comment in zip(values, comments)
        ]

    def append_single_cell_row(self, value: any, style=None):
        """construit une ligne composée d'une seule cellule et l'ajoute à la feuille.
        mêmes paramètres que make_cell:
        value -- contenu de la cellule (texte ou numérique)
        style -- style par défaut de la feuille si non spécifié
        """
        self.append_row([self.make_cell(value, style)])

    def append_blank_row(self):
        """construit une ligne vide et l'ajoute à la feuille."""
        self.append_row([None])

    def append_row(self, row):
        """ajoute une ligne déjà construite à la feuille."""
        self.rows.append(row)

    def prepare(self):
        """génére un flux décrivant la feuille.
        Ce flux pourra ensuite être repris dans send_excel_file (classeur mono feille)
        ou pour la génération d'un classeur multi-feuilles
        """
        for row in self.column_dimensions.keys():
            self.ws.column_dimensions[row] = self.column_dimensions[row]
        for row in self.row_dimensions.keys():
            self.ws.row_dimensions[row] = self.row_dimensions[row]
        for row in self.rows:
            self.ws.append(row)

    def generate(self):
        """génération d'un classeur mono-feuille"""
        # this method makes sense only if it is a standalone worksheet (else call workbook.generate()
        if self.wb is None:  # embeded sheet
            raise ScoValueError("can't generate a single sheet from a ScoWorkbook")

        # construction d'un flux (https://openpyxl.readthedocs.io/en/stable/tutorial.html#saving-as-a-stream)
        self.prepare()
        with NamedTemporaryFile() as tmp:
            self.wb.save(tmp.name)
            tmp.seek(0)
            return tmp.read()