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

from copy import copy
from tools import trace, timer

class Data(object):
    def __init__(self, status = None):
        super(Data, self).__init__()

        self._status = status

        self._name = ""
        self._comment = ""

        self._kp = 0.0
        self._flow = 0.0
        self._cote = 0.0
        self._tiran = 0.0

    def __getitem__(self, key):
        val = None

        if key == "name":
            val = self._name
        elif key == "comment":
            val = self._comment
        elif key == "kp":
            val = self._kp
        elif key == "flow":
            val = self._flow
        elif key == "cote":
            val = self._cote
        elif key == "tiran":
            val = self._tiran

        return val

    def __setitem__(self, key, value):
        if key == "name":
            self._name = str(value)
        elif key == "comment":
            self._comment = str(value)
        elif key == "kp":
            self._kp = float(value)
        elif key == "flow":
            self._flow = float(value)
        elif key == "cote":
            self._cote = float(value)
        elif key == "tiran":
            self._tiran = float(value)

        self._status.modified()

class InitialConditions(object):
    def __init__(self, reach = None, status = None):
        super(InitialConditions, self).__init__()

        self._status = status

        self._reach = reach
        self._data = []

    def __len__(self):
        return len(self._data)

    @property
    def reach(self):
        return self._reach

    @reach.setter
    def reach(self, new):
        self._reach = reach
        self._status.modified()

    @property
    def data(self):
        return self._data.copy()

    def get(self, index):
        return self._data[index]

    def set(self, index, data):
        self._data.insert(index, data)
        self._status.modified()

    def new(self, index):
        n = Data(self._status)
        self._data.insert(index, n)
        self._status.modified()

    def insert(self, index, data):
        self._data.insert(index, data)
        self._status.modified()

    def delete(self, data):
        self._data = list(
            filter(
                lambda x: x not in data,
                self._data
            )
        )
        self._status.modified()

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

    def sort(self, reverse=False, key=None):
        self._data.sort(reverse=reverse, key=key)
        self._status.modified()