# BoundaryConditionList.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 -*-

from copy import copy
from tools import trace, timer

from Model.DB import SQLSubModel
from Model.Except import NotImplementedMethodeError

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

class BoundaryConditionList(SQLSubModel):
    _sub_classes = [
        BoundaryCondition,
    ]

    def __init__(self, status = None):
        super(BoundaryConditionList, self).__init__()

        self._status = status

        self._tabs = {
            "liquid" : [],
            "solid" : [],
            "suspenssion" : []
        }

    @classmethod
    def _sql_create(cls, execute):
        return cls._create_submodel(execute)

    @classmethod
    def _sql_update(cls, execute, version):
        return True

    @classmethod
    def _sql_load(cls, execute, data = None):
        new = cls(status = data['status'])

        if data is None:
            data = {}

        for tab in new._tabs:
            data["tab"] = tab
            new._tabs[tab] = BoundaryCondition._sql_load(
                execute, data
            )

        return new

    def _sql_save(self, execute, data = None):
        execute("DELETE FROM boundary_condition")

        if data is None:
            data = {}

        for tab in self._tabs:
            data["tab"] = tab
            for bc in self._tabs[tab]:
                bc._sql_save(execute, data = data)

        return True

    def len(self, lst):
        return len(self._tabs[lst])

    def get_tab(self, lst):
        return self._tabs[lst].copy()

    def get(self, lst, row):
        return self._tabs[lst][row]

    def set(self, lst, row, new):
        self._tabs[lst][row] = new
        self._status.modified()

    def new(self, lst, index):
        n = NotDefined(status=self._status)
        self._tabs[lst].insert(index, n)
        self._status.modified()
        return n

    def insert(self, lst, index, new):
        self._tabs[lst].insert(index, new)
        self._status.modified()

    def delete(self, lst, bcs):
        for bc in bcs:
            self._tabs[lst].remove(bc)
        self._status.modified()

    def delete_i(self, lst, indexes):
        bcs = list(
            map(
                lambda x: x[1],
                filter(
                    lambda x: x[0] in indexes,
                    enumerate(self._tabs[lst])
                )
            )
        )
        self.delete(lst, bcs)

    def sort(self, lst, reverse=False, key=None):
        self._tabs[lst].sort(reverse=reverse, key=key)
        self._status.modified()

    def move_up(self, lst, index):
        if index < len(self._tabs[lst]):
            next = index - 1

            l = self._tabs[lst]
            l[index], l[next] = l[next], l[index]
            self._status.modified()

    def move_down(self, lst, index):
        if index >= 0:
            prev = index + 1

            l = self._tabs[lst]
            l[index], l[prev] = l[prev], l[index]
            self._status.modified()

    def __copy__(self):
        new = BoundaryConditionList()

        for l in self._tabs:
            new.tabs[l] = self._tabs[l].copy()

        return new

    def __deepcopy__(self):
        new = BoundaryConditionList()

        for l in self._tabs:
            new.tabs[l] = self._tabs[l].deepcopy()

        return new

    def copy(self):
        return copy(self)