Table.py

# Table.py -- Pamhyr
# Copyright (C) 2023  INRAE
#
# 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 3 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, see <https://www.gnu.org/licenses/>.

# -*- coding: utf-8 -*-

import logging
import traceback

from datetime import date, time, datetime, timedelta

from tools import trace, timer

from View.ASubWindow import ASubMainWindow, AWidget
from View.ListedSubWindow import ListedSubWindow

from PyQt5.QtCore import (
    Qt, QVariant, QAbstractTableModel,
    QCoreApplication, QModelIndex, pyqtSlot,
    QRect, QTime, QDateTime,
)

from PyQt5.QtWidgets import (
    QTableView, QAbstractItemView, QSpinBox,
    QTimeEdit, QDateTimeEdit, QItemDelegate,
)

from Model.BoundaryCondition.BoundaryConditionTypes import (
    NotDefined, PonctualContribution,
    TimeOverZ, TimeOverDischarge, ZOverDischarge
)

from View.BoundaryCondition.Edit.UndoCommand import (
    SetDataCommand, AddCommand, DelCommand,
    SortCommand, MoveCommand, PasteCommand,
    DuplicateCommand,
)
from View.BoundaryCondition.Edit.translate import *

_translate = QCoreApplication.translate

logger = logging.getLogger()

class ExtendedTimeEdit(AWidget):
    def __init__(self, parent=None):
        super(ExtendedTimeEdit, self).__init__(
            ui="extendedTimeEdit",
            parent=parent
        )
        self.parent = parent

        self.spinBox_days = self.find(QSpinBox, "spinBox_days")
        self.timeEdit = self.find(QTimeEdit, "timeEdit")

    def set_time(self, time):
        days = 0
        stime = time

        # if ',' in time, time format is 'DD days, HH:MM:SS',
        # otherelse is 'HH:MM:SS'
        if "," in time:
            s = time.strip().split(" ")
            days = int(s[0])
            stime = s[-1]

        qtime = QTime.fromString(
            stime,
            "h:mm:ss"
        )
        self.spinBox_days.setValue(days)
        self.timeEdit.setTime(qtime)

    def get_time(self):
        days = self.spinBox_days.value()
        time = self.timeEdit.time().toPyTime()
        secs = (
            (time.hour * 3600) +
            (time.minute * 60) +
            time.second
        )

        return timedelta(days=days, seconds=secs)

class ExtendedDateTimeEdit(AWidget):
    def __init__(self, parent=None):
        super(ExtendedDateTimeEdit, self).__init__(
            ui="extendedDateTimeEdit",
            parent=parent
        )
        self.parent = parent

        self.dateTimeEdit = self.find(QDateTimeEdit, "dateTimeEdit")

    def set_time(self, time):
        qdatetime = QDateTime.fromString(
            time,
            "yyyy-MM-dd hh:mm:ss"
        )
        self.dateTimeEdit.setDateTime(qdatetime)

    def get_time(self):
        time = self.dateTimeEdit.dateTime().toPyDateTime()
        return time

class ExTimeDelegate(QItemDelegate):
    def __init__(self, data=None, mode="time", parent=None):
        super(ExTimeDelegate, self).__init__(parent)

        self._data = data
        self._mode = mode

    def createEditor(self, parent, option, index):
        if self._mode == "time":
            self.editor = ExtendedTimeEdit(parent=parent)
        else:
            self.editor = ExtendedDateTimeEdit(parent=parent)
        value = index.data(Qt.DisplayRole)
        self.editor.set_time(value)
        logger.debug(str(value))
        return self.editor

    def setModelData(self, editor, model, index):
        time = editor.get_time()
        if self._mode == "time":
            model.setData(index, int(time.total_seconds()))
        else:
            logger.debug(str(time.timestamp()))
            model.setData(index, int(time.timestamp()))
        editor.close()
        editor.deleteLater()

    def updateEditorGeometry(self, editor, option, index):
        r = QRect(option.rect)
        if self.editor.windowFlags() & Qt.Popup and editor.parent() is not None:
            r.setTopLeft(self.editor.parent().mapToGlobal(r.topLeft()))
        editor.setGeometry(r)

    @pyqtSlot()
    def currentItemChanged(self):
        self.commitData.emit(self.sender())


class TableModel(QAbstractTableModel):
    def __init__(self, data=None, mode="time", undo=None):
        super(QAbstractTableModel, self).__init__()
        self._headers = data.header
        self._data = data
        self._mode = mode
        self._undo = undo

    def flags(self, index):
        options = Qt.ItemIsEnabled | Qt.ItemIsSelectable
        options |= Qt.ItemIsEditable

        return options

    def rowCount(self, parent):
        return len(self._data)

    def columnCount(self, parent):
        return len(self._headers)

    def data(self, index, role):
        if role == Qt.TextAlignmentRole:
            return Qt.AlignHCenter | Qt.AlignVCenter

        if role != Qt.ItemDataRole.DisplayRole:
            return QVariant()

        row = index.row()
        column = index.column()

        value = QVariant()

        if 0 <= column < 2:
            v = self._data.get_i(row)[column]
            if self._data.get_type_column(column) == float:
                value = f"{v:.4f}"
            elif self._data.header[column] == "time":
                if self._mode == "time":
                    t0 = datetime.fromtimestamp(0)
                    t = datetime.fromtimestamp(v)
                    value = str(t - t0)
                else:
                    value = str(datetime.fromtimestamp(v))
            else:
                value = f"{v}"

        return value

    def headerData(self, section, orientation, role):
        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
            return table_headers[self._headers[section]]

        return QVariant()

    def setData(self, index, value, role=Qt.EditRole):
        if not index.isValid() or role != Qt.EditRole:
            return False

        row = index.row()
        column = index.column()

        try:
            self._undo.push(
                SetDataCommand(
                    self._data, row, column, value
                )
            )
        except Exception as e:
            logger.info(e)
            logger.debug(traceback.format_exc())

        self.dataChanged.emit(index, index)
        return True

    def add(self, row, parent=QModelIndex()):
        self.beginInsertRows(parent, row, row - 1)

        self._undo.push(
            AddCommand(
                self._data, row
            )
        )

        self.endInsertRows()
        self.layoutChanged.emit()

    def delete(self, rows, parent=QModelIndex()):
        self.beginRemoveRows(parent, rows[0], rows[-1])

        self._undo.push(
            DelCommand(
                self._data, rows
            )
        )

        self.endRemoveRows()

    def sort(self, _reverse, parent=QModelIndex()):
        self.layoutAboutToBeChanged.emit()

        self._undo.push(
            SortCommand(
                self._data, _reverse
            )
        )

        self.layoutAboutToBeChanged.emit()
        self.layoutChanged.emit()

    def move_up(self, row, parent=QModelIndex()):
        if row <= 0:
            return

        target = row + 2

        self.beginMoveRows(parent, row - 1, row - 1, parent, target)

        self._undo_stack.push(
            MoveCommand(
                self._data, "up", row
            )
        )

        self.endMoveRows()
        self.layoutChanged.emit()

    def move_down(self, index, parent=QModelIndex()):
        if row > len(self._data):
            return

        target = row

        self.beginMoveRows(parent, row + 1, row + 1, parent, target)

        self._undo_stack.push(
            MoveCommand(
                self._data, "down", row
            )
        )

        self.endMoveRows()
        self.layoutChanged.emit()

    def paste(self, row, header, data):
        if len(data) == 0:
            return

        self.layoutAboutToBeChanged.emit()

        self._undo.push(
            PasteCommand(
                self._data, row,
                list(
                    map(
                        lambda d: self._data.new_from_data(header, d),
                        data
                    )
                )
            )
        )

        self.layoutAboutToBeChanged.emit()
        self.layoutChanged.emit()


    def undo(self):
        self._undo.undo()
        self.layoutChanged.emit()

    def redo(self):
        self._undo.redo()
        self.layoutChanged.emit()