#!/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 reads and parses the variables, then it generate features.
"""

from typing import List, TypeVar, Dict
import sys
import pandas as pd
import numpy as np
import multiprocessing as mp
from functools import partial
from collections import Counter
from ReadersWriters.ReadersWriters import ReadersWriters
import logging
from Features.FeatureParserThread import FeatureParserThread
from Configs.CONSTANTS import CONSTANTS

PandasDataFrame = TypeVar('DataFrame')
NumpyNdarray = TypeVar('ndarray')

__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 FeatureParser:

    def __init__(self,
                 variables_settings: PandasDataFrame,
                 output_path: str,
                 output_table: str):
        """Initialise the objects and constants.
        :param variables_settings:
        :param output_path: the output path.
        :param output_table: the output table name.
        """
        self.__logger = logging.getLogger(CONSTANTS.app_name)
        self.__logger.debug(__name__)
        self.__variables_settings = variables_settings
        self.__output_path = output_path
        self.__output_table = output_table
        self.__readers_writers = ReadersWriters()
        self.__FeatureParserThread = FeatureParserThread()

    def generate(self,
                 history_table: str,
                 features: PandasDataFrame,
                 variables: PandasDataFrame,
                 prevalence: Dict) -> PandasDataFrame:
        """

        :param history_table: the source table alias name (a.k.a. history table name) that features belong to
            (e.g. inpatient, or outpatient).
        :param features: the output features.
        :param variables: the input variables.
        :param prevalence: the prevalence dictionary of values for all the variables.
        :return: the output features.
        """
        variables_settings = self.__variables_settings[self.__variables_settings["Table_History_Name"] == history_table]

        for _, row in variables_settings.iterrows():
            self.__logger.info("variable: " + row["Variable_Name"] + " ...")

            if not pd.isnull(row["Variable_Aggregation"]):
                postfixes = row["Variable_Aggregation"].replace(' ', '').split(',')
                # aggregate stats
                features_temp = self.__aggregate(
                    variables[row["Variable_Name"]], row["Variable_Type_Original"],
                    postfixes, prevalence[row["Variable_Name"]])
                for p in range(len(postfixes)):
                    # feature name
                    feature_name = row["Variable_Name"] + "_" + postfixes[p]
                    # set
                    features[feature_name] = features_temp[:, p]
            else:
                # init and replace none by zero
                features_temp = np.nan_to_num(variables[row["Variable_Name"]])
                features_temp = np.where(features_temp == np.array(None), 0, features_temp)
                # set
                features[row["Variable_Name"]] = features_temp
        return features

    def __aggregate(self,
                    variable: PandasDataFrame,
                    variable_type: str,
                    postfixes: str,
                    prevalence: Dict) -> NumpyNdarray:
        """

        :param variable: the input variable.
        :param variable_type: the type of input variable.
        :param postfixes: name of the aggregation functions.
        :param prevalence: the prevalence dictionary of values for all the variables.
        :return: the aggregated variable.
        """
        try:
            with mp.Pool() as pool:
                features_temp = pool.map(
                    partial(self.__FeatureParserThread.aggregate_cell, postfixes, variable_type, prevalence), variable)
        except ValueError as exception:
            self.__logger.error(__name__ + " - Invalid configuration(s): " + str(exception))
            sys.exit()

        features_temp = np.asarray(features_temp)
        return features_temp

    def prevalence(self,
                   variable: PandasDataFrame,
                   variable_name: str) -> List:
        """
        :param variable: the input variable.
        :param variable_name: the name of the input variable.
        :return: the prevalence of values for all the variables.
        """
        try:
            with mp.Pool() as pool:
                prevalence_temp = pool.map(
                    partial(self.__FeatureParserThread.prevalence_cell), variable)
        except ValueError as exception:
            self.__logger.error(__name__ + " - Invalid configuration(s): " + str(exception))
            sys.exit()

        prevalence_temp = [sub2 for sub1 in prevalence_temp for sub2 in sub1]
        prevalence = Counter(prevalence_temp).most_common()
        self.__readers_writers.save_text(self.__output_path, self.__output_table,
                                         [variable_name, '; '.join([str(p[0]) + ":" + str(p[1]) for p in prevalence])],
                                         append=True, ext="txt")
        prevalence = [p[0] for p in prevalence]
        return prevalence