# Copyright 2019 miruka
# This file is part of harmonyqml, licensed under LGPLv3.

import asyncio
import json
from pathlib import Path
from typing import Any, Dict

import aiofiles
from dataclasses import dataclass, field

from .backend import Backend
from .theme_parser import convert_to_qml
from .utils import dict_update_recursive

JsonData = Dict[str, Any]

WRITE_LOCK = asyncio.Lock()


@dataclass
class ConfigFile:
    backend:  Backend = field(repr=False)
    filename: str     = field()

    @property
    def path(self) -> Path:
        # pylint: disable=no-member
        return Path(self.backend.app.appdirs.user_config_dir) / self.filename


    async def default_data(self):
        return ""


    async def read(self):
        return self.path.read_text()


    async def write(self, data) -> None:
        async with WRITE_LOCK:
            self.path.parent.mkdir(parents=True, exist_ok=True)

            async with aiofiles.open(self.path, "w") as new:
                await new.write(data)


@dataclass
class JSONConfigFile(ConfigFile):
    async def default_data(self) -> JsonData:
        return {}


    async def read(self) -> JsonData:
        try:
            data = json.loads(await super().read())
        except (FileNotFoundError, json.JSONDecodeError):
            data = {}

        all_data = await self.default_data()
        dict_update_recursive(all_data, data)
        return all_data


    async def write(self, data: JsonData) -> None:
        js = json.dumps(data, indent=4, ensure_ascii=False, sort_keys=True)
        await super().write(js)


@dataclass
class Accounts(JSONConfigFile):
    filename: str = "accounts.json"

    async def any_saved(self) -> bool:
        return bool(await self.read())


    async def add(self, user_id: str) -> None:
        # pylint: disable=no-member
        client = self.backend.clients[user_id]

        await self.write({
            **await self.read(),
            client.user_id: {
                "homeserver": client.homeserver,
                "token":      client.access_token,
                "device_id":  client.device_id,
            }
        })


    async def delete(self, user_id: str) -> None:
        await self.write({
            uid: info
            for uid, info in (await self.read()).items() if uid != user_id
        })


@dataclass
class UISettings(JSONConfigFile):
    filename: str = "ui-settings.json"

    async def default_data(self) -> JsonData:
        return {
            "theme":        "Default.qpl",
            "writeAliases": {},
            "keys": {
                "reloadConfig":  ["Alt+R"],
                "scrollUp":      ["Alt+Up", "Alt+K"],
                "scrollDown":    ["Alt+Down", "Alt+J"],
                "startDebugger": ["Alt+Shift+D"],
            },
        }


@dataclass
class UIState(JSONConfigFile):
    filename: str = "ui-state.json"

    @property
    def path(self) -> Path:
        # pylint: disable=no-member
        return Path(self.backend.app.appdirs.user_data_dir) / self.filename


    async def default_data(self) -> JsonData:
        return {
            "collapseAccounts":    {},
            "collapseCategories":  {},
            "page":                "Pages/Default.qml",
            "pageProperties":      {},
            "sidePaneManualWidth": None,
        }


@dataclass
class Theme(ConfigFile):
    @property
    def path(self) -> Path:
        # pylint: disable=no-member
        data_dir = Path(self.backend.app.appdirs.user_data_dir)
        return data_dir / "themes" / self.filename


    async def default_data(self) -> str:
        async with aiofiles.open("src/themes/Default.qpl", "r") as file:
            return await file.read()


    async def read(self) -> str:
        # pylint: disable=no-member
        if self.backend.app.debug:
            return convert_to_qml(await self.default_data())

        if not self.path.exists():
            await self.write(await self.default_data())

        return convert_to_qml(await super().read())