# (C) 2021 lifegpc
# This file is part of rssbot.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
import sqlite3
from config import RSSConfig
from RSSEntry import RSSEntry, ChatEntry, HashEntry, HashEntries
from typing import List
from enum import Enum, unique
from threading import Lock
from hashl import sha256WithBase64
from time import time


VERSION_TABLE = '''CREATE TABLE version (
id TEXT,
v1 INT,
v2 INT,
v3 INT,
v4 INT,
PRIMARY KEY (id)
);'''


@unique
class userStatus(Enum):
    normalStatus = 0
    needInputChatId = 1


class database:
    def __check_database(self):
        self.__updateExistsTable()
        v = self.__read_version()
        if v is None:
            return False
        if v < self._version:
            if v == [1, 0, 0, 0]:
                self._db.execute('ALTER TABLE RSSList ADD lasterrortime INT;')
            if v < [1, 0, 0, 2]:
                self._db.execute(
                    'ALTER TABLE RSSList ADD forceupdate BOOLEAN;')
                self._db.execute('UPDATE RSSList SET forceupdate=false;')
            if v < [1, 0, 0, 3]:
                self._db.execute('ALTER TABLE RSSList ADD errorcount INT;')
                self._db.execute('UPDATE RSSList SET errorcount=0;')
            if v < [1, 0, 0, 4]:
                self._db.execute('DROP TABLE config;')
                self._db.execute(VERSION_TABLE)
            self.__updateExistsTable()
            self.__write_version()
        return True

    def __create_table(self):
        if 'version' not in self._exist_tables:
            self._db.execute(VERSION_TABLE)
            self.__write_version()
        if 'RSSList' not in self._exist_tables:
            self._db.execute(f'''CREATE TABLE RSSList (
title TEXT,
url TEXT,
interval INT,
lastupdatetime INT,
id TEXT,
lasterrortime INT,
forceupdate BOOLEAN,
errorcount INT,
PRIMARY KEY (id)
);''')
        if 'chatList' not in self._exist_tables:
            self._db.execute('''CREATE TABLE chatList (
chatId INT,
id TEXT,
config TEXT
)''')
        if 'userStatus' not in self._exist_tables:
            self._db.execute('''CREATE TABLE userStatus (
userId INT,
status INT,
hashd TEXT,
PRIMARY KEY (userId)
)''')
        if 'hashList' not in self._exist_tables:
            self._db.execute('''CREATE TABLE hashList (
id TEXT,
hash TEXT,
time INT,
PRIMARY KEY (hash)
)''')
        self._db.commit()

    def __init__(self, m, loc: str):
        self._version = [1, 0, 0, 4]
        self._value_lock = Lock()
        self._db = sqlite3.connect(loc, check_same_thread=False)
        ok = self.__check_database()
        if not ok:
            self.__create_table()
        from rssbot import main
        self._main: main = m

    def __isNewVersionType(self):
        if 'version' in self._exist_tables:
            return True
        else:
            return False

    def __removeRSSEntry(self, id: str) -> bool:
        try:
            self._db.execute(f'DELETE FROM RSSList WHERE id=?;', (id,))
            self._db.execute(f'DELETE FROM hashList WHERE id=?;', (id,))
            self._db.commit()
            return True
        except:
            return False

    def __write_version(self):
        if self.__read_version() is None:
            self._db.execute('INSERT INTO version VALUES (?, ?, ?, ?, ?);',
                             tuple(['main'] + self._version))
        else:
            self._db.execute(
                "UPDATE version SET v1=?, v2=?, v3=?, v4=? WHERE id='main';",
                tuple(self._version))
        self._db.commit()

    def __read_version(self) -> List[int]:
        if self.__isNewVersionType():
            cur = self._db.execute("SELECT * FROM version WHERE id='main';")
            for i in cur:
                return [k for k in i if isinstance(k, int)]
        else:
            cur = self._db.execute(f'SELECT * FROM config;')
            for i in cur:
                return [k for k in i]

    def __updateExistsTable(self):
        cur = self._db.execute('SELECT * FROM main.sqlite_master;')
        self._exist_tables = {}
        for i in cur:
            if i[0] == 'table':
                self._exist_tables[i[1]] = i

    def addRSSList(self, title: str, url: str, chatId: int, config: RSSConfig, ttl: int = None, hashEntries: HashEntries = None):
        with self._value_lock:
            try:
                hashd = sha256WithBase64(url)
                cur = self._db.execute(
                    f'SELECT * FROM RSSList WHERE id=?;', (hashd,))
                has_data = False
                for i in cur:  # pylint: disable=unused-variable
                    has_data = True
                    break
                if has_data:
                    self._db.execute(
                        f"UPDATE RSSList SET title=?, interval=? WHERE id=?;",
                        (title, ttl if ttl is not None else 'null', hashd))
                else:
                    self._db.execute(
                        f"INSERT INTO RSSList VALUES (?, ?, ?, ?, ?, null, false, 0);",
                        (title, url, ttl if ttl is not None else 'null',
                         int(time()), hashd))
                cur = self._db.execute(
                    f'SELECT * FROM chatList WHERE id=? AND chatId=?;',
                    (hashd, chatId))
                has_data2 = False
                for i in cur:
                    has_data2 = True
                    break
                if has_data2:
                    self._db.execute(
                        f'DELETE FROM chatList WHERE id=? AND chatId=?;',
                        (hashd, chatId))
                self._db.execute(
                    f"INSERT INTO chatList VALUES (?, ?, ?);",
                    (chatId, hashd, config.toJson()))
                if hashEntries is not None and not has_data:
                    cur = self._db.execute(
                        f"SELECT * FROM hashList WHERE id=?;", (hashd,))
                    has_data3 = False
                    for i in cur:
                        has_data3 = True
                        break
                    if has_data3:
                        self._db.execute(
                            f"DELETE FROM hashList WHERE id=?;", (hashd,))
                    for v in hashEntries.getList():
                        self._db.execute(
                            f"INSERT INTO hashList VALUES (?, ?, ?);",
                            (v.id, v.hash, v.time))
                self._db.commit()
                return True
            except:
                return False

    def getAllRSSList(self) -> List[RSSEntry]:
        with self._value_lock:
            cur = self._db.execute(f'SELECT * FROM RSSList;')
            r = []
            for i in cur:
                temp = RSSEntry(i, self._main._setting._maxCount)
                cur2 = self._db.execute(
                    f'SELECT * FROM chatList WHERE id=?;', (temp.id,))
                for i2 in cur2:
                    temp2 = ChatEntry(i2)
                    temp.chatList.append(temp2)
                cur3 = self._db.execute(
                    f"SELECT * FROM hashList WHERE id=? ORDER BY time;", (temp.id,))
                for i3 in cur3:
                    temp.hashList.add(HashEntry(i3))
                if len(temp.chatList) == 0:
                    self.__removeRSSEntry(temp.id)
                else:
                    r.append(temp)
            return r

    def getRSSListByChatId(self, chatId: int) -> List[RSSEntry]:
        with self._value_lock:
            cur = self._db.execute(
                f"SELECT RSSList.title, RSSList.url, RSSList.interval, RSSList.lastupdatetime, RSSList.id, RSSList.lasterrortime, RSSList.forceupdate, RSSList.errorcount, chatList.config FROM RSSList, chatList WHERE chatList.chatId = ? AND RSSList.id = chatList.id ORDER BY title;", (chatId,))
            RSSEntries = []
            for i in cur:
                rssEntry = RSSEntry(i, self._main._setting._maxCount)
                rssEntry.chatList.append(ChatEntry((chatId, i[4], i[8])))
                RSSEntries.append(rssEntry)
            return RSSEntries

    def getUserStatus(self, userId: int) -> (userStatus, str):
        with self._value_lock:
            try:
                cur = self._db.execute(
                    f'SELECT * FROM userStatus WHERE userId=?;', (userId,))
                for i in cur:
                    return userStatus(i[1]), i[2]
            except:
                pass
            return userStatus.normalStatus, ''

    def removeItemInChatList(self, chatId: int, id: str):
        with self._value_lock:
            try:
                self._db.execute(
                    f"DELETE FROM chatList WHERE chatId=? AND id=?;",
                    (chatId, id))
                self._db.commit()
                return True
            except:
                return False

    def setRSSForceUpdate(self, url: str, forceupdate: bool) -> bool:
        with self._value_lock:
            try:
                hashd = sha256WithBase64(url)
                cur = self._db.execute(
                    f'SELECT * FROM RSSList WHERE id=?;', (hashd,))
                has_data = False
                for i in cur:  # pylint: disable=unused-variable
                    has_data = True
                    break
                if not has_data:
                    return False
                self._db.execute(
                    f"UPDATE RSSList SET forceupdate=? WHERE id=?;",
                    ('true' if forceupdate else 'false', hashd))
                self._db.commit()
                return True
            except:
                return False

    def setUserStatus(self, userId: int, status: userStatus = userStatus.normalStatus, hashd: str = '') -> bool:
        with self._value_lock:
            try:
                cur = self._db.execute(
                    f'SELECT * FROM userStatus WHERE userId=?;', (userId,))
            except:
                return False
            have_data = False
            now = None
            for i in cur:
                have_data = True
                try:
                    now = (userStatus(i[1]), i[2])
                except:
                    pass
            if have_data and now is not None and now[0] == status and now[1] == hashd:
                return True
            try:
                if have_data:
                    cur = self._db.execute(
                        f'UPDATE userStatus SET status=?, hashd=? WHERE userId=?;',
                        (status.value, hashd, userId))
                else:
                    cur = self._db.execute(
                        f'INSERT INTO userStatus VALUES (?, ?, ?);',
                        (userId, status.value, hashd))
                self._db.commit()
                return True
            except:
                return False

    def updateChatConfig(self, chatEntry: ChatEntry) -> bool:
        with self._value_lock:
            try:
                cur = self._db.execute(
                    f"SELECT * FROM chatList WHERE chatId=? AND id=?;",
                    (chatEntry.chatId, chatEntry.id))
                has_data = False
                for i in cur:  # pylint: disable=unused-variable
                    has_data = True
                    break
                if not has_data:
                    return False
                self._db.execute(
                    f"UPDATE chatList SET config=? WHERE chatId=? AND id=?;",
                    (chatEntry.config.toJson(), chatEntry.chatId, chatEntry.id))
                self._db.commit()
                return True
            except:
                return False

    def updateRSS(self, title: str, url: str, lastupdatetime: int, hashEntries: HashEntries, ttl: int = None):
        with self._value_lock:
            try:
                hashd = sha256WithBase64(url)
                cur = self._db.execute(
                    f'SELECT * FROM RSSList WHERE id=?;', (hashd,))
                has_data = False
                for i in cur:  # pylint: disable=unused-variable
                    has_data = True
                    break
                if not has_data:
                    return False
                self._db.execute(
                    f"UPDATE RSSList SET title=?, interval=?, lastupdatetime=?, errorcount=0 WHERE id=?;",
                    (title, ttl if ttl is not None else 'null', lastupdatetime, hashd))
                cur = self._db.execute(
                    f"SELECT * FROM hashList WHERE id=?;", (hashd,))
                has_data2 = False
                for i in cur:
                    has_data2 = True
                    break
                if has_data2:
                    self._db.execute(
                        f"DELETE FROM hashList WHERE id=?;", (hashd,))
                for v in hashEntries.getList():
                    self._db.execute(
                        f"INSERT INTO hashList VALUES (?, ?, ?);",
                        (v.id, v.hash, v.time))
                self._db.commit()
                return True
            except:
                return False

    def updateRSSWithError(self, url: str, lasterrortime: int):
        with self._value_lock:
            try:
                hashd = sha256WithBase64(url)
                cur = self._db.execute(
                    f'SELECT * FROM RSSList WHERE id=?;', (hashd,))
                has_data = False
                for i in cur:
                    rss = RSSEntry(i, self._main._setting._maxCount)
                    has_data = True
                    break
                if not has_data:
                    return False
                self._db.execute(
                    f"UPDATE RSSList SET lasterrortime=?, errorcount=? WHERE id=?;", (lasterrortime, rss.errorcount + 1, hashd))
                self._db.commit()
                return True
            except:
                return False