#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
# Copyright 2017 University of Westminster. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
""" It is an interface for reading and writing configuration file using 'configParser'.
"""

from typing import Dict, List
import sys
import configparser
import os
import logging

__author__ = "Mohsen Mesgarpour"
__copyright__ = "Copyright 2016, https://github.com/mesgarpour"
__credits__ = ["Mohsen Mesgarpour"]
__license__ = "GPL"
__version__ = "1.1"
__maintainer__ = "Mohsen Mesgarpour"
__email__ = "mohsen.mesgarpour@gmail.com"
__status__ = "Release"


class PyConfigParser:
    def __init__(self,
                 path: str,
                 app_name: str,
                 ext: str= ""):
        """Initialise the objects and constants.
        :param path: the file path of the configuration file.
        :param app_name: the application name, which will be used as the log file name.
        :param ext: the extension of the configuration file (default: 'ini').
        """
        self.__logger = logging.getLogger(app_name)
        self.__logger.debug(__name__)
        self.__path = os.path.abspath(path + "." + ext)
        self.__config = None
        self.refresh()

    def refresh(self):
        """Refresh the configuration file reader and Reset the constants.
        """
        self.__logger.debug("Refresh the Configuration file reader.")
        try:
            if not (os.path.exists(self.__path) and os.path.isfile(self.__path)):
                self.__logger.warning(__name__ + " - Configuration file does not exist: \n" + self.__path)
                self.reset()
            else:
                self.__config = configparser.ConfigParser()
                self.__config.optionxform = str  # make option case-sensitive
                self.__config.read(self.__path)
        except():
            self.__logger.error(__name__ + " - Error while opening a file: \n" + self.__path)
            sys.exit()

    def reset(self):
        """Reset the configuration file reader.
        """
        self.__logger.debug("Reset the Configuration file.")
        try:
            open(self.__path, 'w').close()
        except():
            self.__logger.error(__name__ + " - Could not create the config file: \n" + self.__path)
            sys.exit()

    def sections(self) -> List:
        """Get sections in the configuration file.
        :return: section names.
        """
        self.__logger.debug("Get Sections of the Configuration file.")
        return self.__config.sections()

    def subsections(self,
                    section: str) -> List:
        """Get sub-sections under the specified section name.
        :param section: the section name.
        :return: the sub-section names
        """
        self.__logger.debug("Get Subsections of the Configuration file.")
        return self.__config.items(section)

    def option(self,
               section: str,
               key: str) -> str:
        """Get the option for the specified key and section.
        :param section: a section in the configuration.
        :param key: a key of a section in the configuration.
        :return: the value (option) of the key.
        """
        self.__logger.debug("Read an Option in the Configuration file.")
        try:
            value = self.__config.get(section, key)
        except configparser.NoSectionError:
            self.__logger.error(__name__ + " - Invalid Section: [Section: " +
                                str(section) + "; Key:" + str(key) + "]")
            sys.exit()
        except configparser.NoOptionError:
            self.__logger.error(__name__ + " - Invalid Option: [Section: " +
                                str(section) + "; Key:" + str(key) + "]")
            sys.exit()
        except():
            self.__logger.error(__name__ + " - Invalid Configuration: [Section: " +
                                str(section) + "; Key:" + str(key) + "]")
            sys.exit()
        return value

    def options(self,
                section: str,
                keys: List=None) -> Dict:
        """Get the options for all or the specified keys in the section.
        :param section: a section in the configuration.
        :param keys: keys of a section (option) in the configuration.
        :return: the values (options) of the keys.
        """
        self.__logger.debug("Read Section Options in the Configuration file.")
        values = []
        try:
            if keys is None:
                values = dict(self.subsections(section))
            else:
                for k in keys:
                    values.append(self.__config.get(section, k))
        except configparser.NoSectionError:
            self.__logger.error(__name__ + " - Invalid Section: " +
                                "[Section: " + str(section) + "]")
            sys.exit()
        except():
            self.__logger.error(__name__ + " - Invalid Configuration.")
            sys.exit()
        return values

    def read_dict(self,
                  section: str=None) -> Dict:
        """Read the configuration and save into dictionary.
        :param section: the section name
        :return: the read configuration file
        """
        self.__logger.debug("Read into Dictionary.")
        dic = dict()
        sections = self.sections()

        if section is None:
            for section in sections:
                dic[section] = self.options(section)
                for k, v in dic[section].items():
                    dic[section][k] = str(v).split(',')
        else:
            if section in set(sections):
                dic = self.options(section)
                for k, v in dic.items():
                    dic[k] = str(v).split(',')
        return dic

    def write_dict(self,
                   dic: Dict,
                   section: str,
                   append: str=False):
        """Write from the inputted dictionary into the configuration file.
        :param dic: the inputted dictionary to write into the configuration file.
        :param section: the section name.
        :param append: indicates if the write appends to any existing configuration file.
        """
        self.__logger.debug("Write from Dictionary.")
        # set
        config = configparser.RawConfigParser()
        config.optionxform = str  # make option is case-sensitive
        config.add_section(section)
        keys = list(dic.keys())

        for key in keys:
            if isinstance(dic[key], list):
                config.set(section, key, ','.join(dic[key]))
            else:
                config.set(section, key, dic[key])

        # write
        if append is False:
            with open(self.__path, 'w') as file:
                config.write(file)
        else:
            with open(self.__path, 'a') as file:
                config.write(file)

    def write_option(self,
                     section: str,
                     option: str,
                     value: str):
        """Remove then add the specified option to the configuration file.
        :param section: the section name.
        :param option: the option name to be removed then added with new value.
        :param value: the option value to be removed then added with new value.
        """
        self.__logger.debug("Write an Option into the Configuration file.")
        self.__remove_option(section, option)
        self.__add_option(section, option, value)

    def __remove_option(self,
                        section: str,
                        option: str):
        """Remove an option from the configuration file.
        :param section: the section name.
        :param option: the option name to remove.
        """
        self.__logger.debug("Remove an Option from the Configuration file.")
        section = "[" + section + "]"
        option += "="
        match = False

        # read
        with open(self.__path, 'r') as file:
            lines = file.readlines()

        # delete
        with open(self.__path, 'w') as file:
            # remove
            for line in lines:
                if line.strip().startswith(section):
                    match = True
                if match is True and line.replace(' ', '').startswith(option):
                    match = False
                    continue
                file.write(line)

    def __add_option(self,
                     section: str,
                     option: str,
                     value: str):
        """Add an option to the configuration file.
        :param section: the section name.
        :param option: the option name to be written.
        :param value: the option value to be written.
        """
        self.__logger.debug("Add an Option to the Configuration file.")
        section = "[" + section + "]"
        match = False

        # read
        with open(self.__path, 'r') as file:
            lines = file.readlines()

        # append
        with open(self.__path, 'w') as file:
            for line in lines:
                if line.strip().startswith(section):
                    file.write(line)
                    file.write(option + " = " + ",".join(value) + "\n")
                    match = True
                else:
                    file.write(line)
            if match is False:
                file.write("\n" + section + "\n" + option + " = " + ",".join(value) + "\n")