# -*- coding: utf-8 -*-
"""
Copyright (C) 2011 Oliver Tengler

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""

import re
import types
import unittest
from typing import TypeVar, Any, Dict, Callable, Tuple, Iterator, cast
from tools.FileTools import fopen

T = TypeVar('T')

def identity (a: T) -> T:
    return a

def boolParse (value: Any) -> bool:
    if type(value) == bool:
        return cast(bool, value)
    if type(value) == str:
        value = value.lower()
        if value == "true" or value == "1" or value == "yes":
            return True
        if value == "false" or value == "0" or value == "no":
            return False
    if type(value) == int:
        return bool(value)
    raise RuntimeError("Unknown boolean value '" + value + "'")

def boolPersist (value: Any) -> str:
    if type(value) == bool:
        return str(value)
    if type(value) == str:
        value = value.lower()
        if value == "true" or value == "1" or value == "yes":
            return "True"
        if value == "false" or value == "0" or value == "no":
            return "False"
    if type (value) == int:
        if value:
            return "True"
        return "False"
    raise RuntimeError("Cannot interpret '" + str(value) + "' as bool")

def plainTypeMapper(t: Any) -> Tuple[Callable, Callable, Callable]:
    if bool == t:
        return (boolParse, lambda: None, boolPersist)
    if int == t:
        return (int, lambda: None, str)
    return (identity,  lambda: None,  str)

# A object which holds configuration data. The data is accessed like a property. It can contain objects of itself
# which allows to build deeper stacked configs.
# E.g.:
# c = Config()
# c.sub = Config()
# c.sub.a = "Text"
class Config:
    def __init__ (self, name: str="", dataMap: Dict[str,Any]=None,  configLines:Iterator[str]=None,  typeInfoFunc: Callable=None) -> None:
        self.__data = dataMap or {}
        self.__typeMapper: Dict[str,Tuple[Callable,Callable,Callable]] = {}
        if typeInfoFunc:
            typeInfoFunc(self)
        if name:
            self.loadFile(name)
        elif configLines:
            self.parseLines(configLines)

    def setPlainType(self, attr: str, attrType: Any) -> None:
        self.__typeMapper[attr.lower()] = plainTypeMapper(attrType)

    def setType (self, attr: str, typeFuncs: Tuple[Callable, Callable, Callable]) -> None:
        self.__typeMapper[attr.lower()] = typeFuncs

    def __typeParse (self, attr: str) -> Callable:
        if attr in self.__typeMapper:
            return self.__typeMapper[attr][0]
        return lambda a: a

    def __typeNotFound (self, attr: str) -> Callable:
        if attr in self.__typeMapper:
            return self.__typeMapper[attr][1]
        return lambda:None

    def __typePersist (self, attr: str) -> Callable:
        if attr in self.__typeMapper:
            return self.__typeMapper[attr][2]
        return str

    def __getattr__ (self,  attr: str) -> Any:
        attr = attr.lower()
        if attr in self.__data:
            return self.__typeParse(attr)(self.__data[attr])
        result = self.__typeNotFound(attr)()
        if result is not None:
            if isinstance(result, Config):
                self.__data[attr] = result
            return result
        raise AttributeError(attr + " does not exist in the configuration")

    def __getitem__(self, attr: str) -> Any:
        attr = attr.lower()
        return self.__data[attr]

    def __contains__(self,  attr: str) -> bool:
        return attr.lower() in self.__data

    def __setattr__(self, attr: str, value: Any) -> None:
        if attr.startswith("_Config__"):
            super().__setattr__(attr, value)
            return 
        attr = attr.lower()
        if isinstance(value, Config):
            self.__data[attr] = value
        else:
            v = self.__typeParse(attr)(value)
            self.__data[attr] = v

    def __iter__(self) -> Any:
        return self.__data.__iter__()

    def values(self) -> Any:
        return self.__data.values()

    def __repr__ (self) -> str:
        return self.__dumpRec (self, 0)

    def __dumpRec (self, config: 'Config',  level: int) -> str:
        s = ""
        for k,v in config.__data.items(): # access of protected member pylint: disable=W0212
            if s:
                s += "\n"
            s = s + " " *2*level + k
            if type(v) is Config:
                s += " {\n"
                s = s + self.__dumpRec (v,  level+1)
                s = s + "\n" + " " *2*level + "}"
            else:
                s = s + " = " + config.__typePersist(k)(v) # access of protected member pylint: disable=W0212
        return s

    def remove (self, key: str) -> None:
        key = key.lower()
        if key in self.__data:
            del self.__data[key]

    def loadFile (self, name: str) -> None:
        with fopen(name) as file:
            self.parseLines ((line for line in file.readlines()))

    def parseLines(self, lines: Iterator[str]) -> None:
        if type(lines) is not types.GeneratorType:
            raise TypeError("lines must be a generator type")
        for line in lines:
            line = line.strip()
            try:
                if not line or line.startswith("#"): # ignore empty lines and comments
                    continue
                equalSign = line.find("=")
                if equalSign != -1:
                    key = line[:equalSign]
                    value = line[equalSign+1:]
                    setattr(self, key.strip(),  value.strip())
                elif line.startswith("import"):
                    self.__handleImport(line)
                elif line.startswith("}"):
                    return
                elif line.endswith("{"):
                    groupname = line.split("{")[0].strip().lower()
                    if groupname in self.__data:
                        group = self.__data[groupname]
                        group.parseLines (lines)
                    else:
                        try:
                            group = getattr(self, groupname) # This allows to apply type information from __typeNotFound funcs
                        except AttributeError:
                            group = Config()
                        group.parseLines(lines)
                        setattr (self,  groupname,  group)
            except:
                print ("Do not understand line: " + line)
                raise

    def __handleImport (self, line: str) -> None:
        # syntax: import file as groupname
        # This imports the file into the group 'groupname'. If the group already exists it is merged
        importTokens = re.match("import\\W+([\\w\\\\/\\.]+)\\W+as\\W+(\\w+)", line)
        if importTokens:
            groupname = importTokens.group(2).lower()
            filename = importTokens.group(1)

            try:
                group = getattr(self, groupname) # This allows to apply type information from __typeNotFound funcs
            except AttributeError:
                group = Config()

            try:
                group.loadFile (filename)
                setattr (self,  groupname,  group)
            except IOError:
                pass
        else:
            # syntax: import file
            # This imports all properties of the file into the current config.
            importTokens = re.match("import\\W+([\\w\\\\/\\.]+)", line)
            if not importTokens:
                raise RuntimeError("wrong import line")
            try:
                Config(importTokens.group(1), dataMap=self.__data)
            except IOError:
                pass

def typeDefaultBool (bDefault: bool) -> Tuple[Callable, Callable, Callable]:
    return (boolParse, lambda: bDefault, boolPersist)

def typeDefaultInt (iDefault: int) -> Tuple[Callable, Callable, Callable]:
    return (int, lambda: iDefault, str)

def typeDefaultString (strDefault: str) -> Tuple[Callable, Callable, Callable]:
    return (identity, lambda: strDefault, str)

def typeDefaultConfig () -> Tuple[Callable, Callable, Callable]:
    return (identity, lambda: Config(), identity) # Lambda may not be neccessary pylint: disable=W0108
class TestConfig(unittest.TestCase):
    def test(self) -> None:
        c = Config()
        c.setPlainType ("b1", bool)
        c.setType("b2",  typeDefaultBool(True))
        with self.assertRaises(AttributeError):
            c.b1 # pylint: disable=W0104
        self.assertEqual(c.b2, True)
        c.b1 = False # pylint: disable=W0201
        self.assertEqual(c.b1, False)
        c.text = "Hallo" # pylint: disable=W0201
        self.assertEqual(c.text, "Hallo")
        c.setType("di",  typeDefaultInt(42))
        self.assertEqual(c.di, 42)
        c.setType("ds",  typeDefaultString("Spam"))
        self.assertEqual(c.ds, "Spam")
        hasB1 = "b1" in c
        self.assertEqual(hasB1,  True)
        hasX1 = "x1" in c
        self.assertEqual(hasX1,  False)

if __name__ == "__main__":
    unittest.main()