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

from tools import trace, timer

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

class SedimentLayerList(SQLSubModel):
    _sub_classes = [SedimentLayer]

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

        self._status = status
        self._sl = []

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

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

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

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

        new._sl = SedimentLayer._sql_load(execute, data)

        return new

    def _sql_save(self, execute, data = None):
        ok = True

        # Delete previous data
        execute("DELETE FROM sedimentary_layer")
        execute("DELETE FROM sedimentary_layer_layer")

        for sl in self._sl:
            ok &= sl._sql_save(execute, data)

        return ok

    @property
    def sediment_layers(self):
        return self._sl.copy()

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

    def set(self, index, new):
        self._sl[index] = new
        self._status.modified()

    def insert(self, index, new):
        self._sl.insert(index, new)
        self._status.modified()

    def new(self, index):
        n = SedimentLayer(status = self._status)
        self.insert(index, n)
        self._status.modified()
        return n

    def delete(self, els):
        for el in els:
            self._sl.remove(el)
        self._status.modified()

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

    def move_up(self, index):
        if index < len(self._sl):
            next = index - 1

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

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

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