import warnings
from functools import wraps

import numpy

import pandas

import recordlinkage.config as cf

# Errors and Exception handlers
class IndexError(Exception):
    """ Error class for errors related to indexing. """

class LearningError(Exception):
    """Learning error"""

class DeprecationHelper(object):
    """Deprecation helper for classes and functions.

    Based on

    def __init__(self, new_target, msg=None):
        self.new_target = new_target
        self.msg = msg

    def _warn(self):

        from warnings import warn

        if self.msg is None:
            msg = "This class will get deprecated."
            msg = self.msg

        warn(msg, DeprecationWarning, stacklevel=1)

    def __call__(self, *args, **kwargs):
        return self.new_target(*args, **kwargs)

    def __getattr__(self, attr):
        return getattr(self.new_target, attr)

def return_type_deprecator(func):

    def func_wrapper(*args, **kwargs):
        return_type = kwargs.pop('return_type', None)
        if return_type is not None:
                "The argument 'return_type' is deprecated in the next "
                "version. Use recordlinkage.set_option('classification."
                "return_type', '{}') instead.".format(return_type),
            with cf.option_context('classification.return_type', return_type):
                return func(*args, **kwargs)
            return func(*args, **kwargs)

    return func_wrapper

# Checks and conversions
def is_label_dataframe(label, df):
    """check column label existance"""

    setdiff = set(label) - set(df.columns.tolist())

    if len(setdiff) == 0:
        return True
        return False

def get_length(x):
    """Return int or len(x)"""

        return int(x)
    except Exception:
        return len(x)

def listify(x, none_value=[]):
    """Make a list of the argument if it is not a list."""

    if isinstance(x, list):
        return x
    elif isinstance(x, tuple):
        return list(x)
    elif x is None:
        return none_value
        return [x]

def unique(x):
    """Convert a list in a unique list."""

    return list(set(x))

def merge_dicts(*dict_args):
    Given any number of dicts, shallow copy and merge into a new dict,
    precedence goes to key value pairs in latter dicts.
    result = {}
    for dictionary in dict_args:
    return result

def multi_index_to_frame(index):
    Replicates MultiIndex.to_frame, which was introduced in pandas 0.21,
    for the sake of backwards compatibility.
    return pandas.DataFrame(index.tolist(), index=index, columns=index.names)

def index_split(index, chunks):
    """Function to split pandas.Index and pandas.MultiIndex objects.

    Split :class:`pandas.Index` and :class:`pandas.MultiIndex` objects
    into chunks. This function is based on :func:`numpy.array_split`.

    index : pandas.Index, pandas.MultiIndex
        A pandas.Index or pandas.MultiIndex to split into chunks.
    chunks : int
        The number of parts to split the index into.

        A list with chunked pandas.Index or pandas.MultiIndex objects.


    Ntotal = index.shape[0]
    Nsections = int(chunks)
    if Nsections <= 0:
        raise ValueError('number sections must be larger than 0.')
    Neach_section, extras = divmod(Ntotal, Nsections)
    section_sizes = ([0] + extras * [Neach_section + 1] +
                     (Nsections - extras) * [Neach_section])
    div_points = numpy.array(section_sizes).cumsum()

    sub_ind = []
    for i in range(Nsections):
        st = div_points[i]
        end = div_points[i + 1]

    return sub_ind

def split_index(*args, **kwargs):

    warnings.warn("Function will be removed in the future. Use index_split.",

    return index_split(*args, **kwargs)

def frame_indexing(frame, multi_index, level_i, indexing_type='label'):
    """Index dataframe based on one level of MultiIndex.

    frame : pandas.DataFrame
        The datafrme to select records from.
    multi_index : pandas.MultiIndex
        A pandas multiindex were one fo the levels is used to sample the
        dataframe with.
    level_i : int, str
        The level of the multiIndex to index on.
    indexing_type : str
        The type of indexing. The value can be 'label' or 'position'.
        Default 'label'.


    if indexing_type == "label":
        data = frame.loc[multi_index.get_level_values(level_i)]
        data.index = multi_index
    elif indexing_type == "position":
        data = frame.iloc[multi_index.get_level_values(level_i)]
        data.index = multi_index
        raise ValueError("indexing_type needs to be 'label' or 'position'")

    return data

def fillna(series_or_arr, missing_value=0.0):
    """Fill missing values in pandas objects and numpy arrays.

    series_or_arr : pandas.Series, numpy.ndarray
        The numpy array or pandas series for which the missing values
        need to be replaced.
    missing_value : float, int, str
        The value to replace the missing value with. Default 0.0.

    pandas.Series, numpy.ndarray
        The numpy array or pandas series with the missing values

    if pandas.notnull(missing_value):
        if isinstance(series_or_arr, (numpy.ndarray)):
            series_or_arr[numpy.isnan(series_or_arr)] = missing_value
            series_or_arr.fillna(missing_value, inplace=True)

    return series_or_arr