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

import os
from datetime import datetime

from Model.DB import SQLModel
from Model.Saved import SavedStatus
from Model.Serializable import Serializable
from Model.Except import NotImplementedMethodeError
from Model.River import River

from Checker.Study import *

class Study(SQLModel):
    _sub_classes = [
        River,
    ]

    def __init__(self, filename = None, init_new = True):
        # Metadata
        self._version = "0.0.0"
        self.creation_date = datetime.now()
        self.last_modification_date = datetime.now()
        self.last_save_date = datetime.now()

        self._filename = filename
        super(Study, self).__init__(filename = filename)

        self.status = SavedStatus()

        # Study general information
        self._name = ""
        self.description = ""
        # Time system
        self._time_system = "time"
        self._date = datetime.fromtimestamp(0)

        if init_new:
            # Study data
            self._river = River(status = self.status)
        else:
            self._init_db_file(filename, is_new = False)

    @classmethod
    def checkers(cls):
        lst = [
            StudyNetworkReachChecker(),
            StudyGeometryChecker(),
            # DummyOK(),
            # DummyWARNING(),
            # DummyERROR(),
        ]

        return lst

    @property
    def river(self):
        return self._river

    @property
    def is_saved(self):
        return self.status.is_saved()

    def save(self):
        self.last_save_date = datetime.now()
        self.status.save()
        self._save()

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = str(name)
        self.status.modified()

    @property
    def filename(self):
        return self._filename

    @filename.setter
    def filename(self, filename):
        self._filename = str(filename)
        self._init_db_file(filename, is_new = True)

    @property
    def time_system(self):
        return self._time_system

    def use_time(self):
        self._time_system = "time"
        self.status.modified()

    def use_date(self, date:datetime):
        self._time_system = "date"
        self._date = date
        self.status.modified()

    @property
    def date(self):
        return self._date

    @date.setter
    def date(self, timestamp):
        self._date = timestamp
        self.status.modified()

    # @classmethod
    # def new(cls):
    #     return cls()

    @classmethod
    def new(cls, name, description, date = None):
        me = cls()
        me.name = name
        me.description = description
        if date is not None:
            me.use_date()
            me.date = date
        return me

    @classmethod
    def open(cls, filename):
        me = cls._load(filename)
        return me

    #######
    # SQL #
    #######

    def _create(self):
        # Info (metadata)
        self.execute("CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")
        self.execute(
            f"INSERT INTO info VALUES ('version', '{self._sql_format(self._version)}')",
            commit = True
        )

        self._create_submodel()
        self.commit()

    def _update(self):
        version = self.execute(f"SELECT value FROM info WHERE key='version'")

        print(f"{version[0]} == {self._version}")
        if version[0] == self._version:
            return True

        if self._update_submodel(version):
            self.execute(f"UPDATE info SET value='{self._version}' WHERE key='version'")
            return True

        print("TODO: update failed")
        raise NotImplementedMethodeError(self, self._update)

    @classmethod
    def _load(cls, filename):
        new = cls(init_new = False, filename = filename)

        # TODO: Load metadata
        print("TODO: Load metadata")

        # Load river data
        new._river = River._sql_load(
            lambda sql: new.execute(
                sql,
                fetch_one = False,
                commit = True
            ),
            data = {"status": new.status}
        )

        return new

    def _save(self):
        self._save_submodel([self._river])
        self.commit()