# -*- coding: utf-8 -*-
"""
Objects that represent dimensions or axes of scientific datasets

Created on Thu Jul  7 21:14:25 2020

@author: Gerd Duscher, Suhas Somnath
"""

from __future__ import division, print_function, unicode_literals, \
    absolute_import
from warnings import warn
import sys
import numpy as np
from enum import Enum
from sidpy.base.string_utils import validate_single_string_arg
import copy

__all__ = ['Dimension', 'DimensionType']

if sys.version_info.major == 3:
    unicode = str


class DimensionType(Enum):
    """
    Physical type of Dimension object. This information will be used for
    visualization and processing purposes.
    """
    UNKNOWN = -1
    SPATIAL = 1
    RECIPROCAL = 2
    SPECTRAL = 3
    TEMPORAL = 4
    CHANNEL = 5
    POINT_CLOUD = 6


class Dimension(np.ndarray):
    """
    """

    def __new__(cls, values, name='none', quantity='generic', units='generic',
                dimension_type=DimensionType.UNKNOWN, *args, **kwargs):
        """
        Parameters
        ----------
        name : str or unicode
            Name of the dimension. For example 'X'
        quantity : str or unicode
            Quantity for this dimension. For example: 'Length'
        units : str or unicode
            Units for this dimension. For example: 'um'
        values : array-like or int
            Values over which this dimension was varied. A linearly increasing
            set of values will be generated if an integer is provided instead
            of an array.
        dimension_type : str or sidpy.sid.dimension.DimensionType
            For example: 'spectral', 'spatial', 'reciprocal', 'channel', or 'UNKNOWN',
            'time', 'frame', 'reciprocal'
            This will determine how the data are visualized. 'spatial' are
            image dimensions. 'spectral' indicate spectroscopy data dimensions.

        Attributes
        ----------
        self.name : str
            Name of the dimension
        self.quantity : str
            Physical quantity. E.g. - current
        self.units : str
            Physical units. E.g. - amperes
        self.dimension_type : enum
            Type of dimension. E.g. - Spectral, Spatial, etc.
        self.values : array-like
            Values over which this dimension was varied
        """
        if isinstance(values, int):
            if values < 1:
                raise TypeError("When specifying the size of a Dimension, "
                                "values should at be integers > 1")
            values = np.arange(values)
        elif len(np.array(values)) < 1:
            raise TypeError("When specifying values over which a parameter is "
                            "varied, values should not be an empty array")
        if np.array(values).ndim != 1:
            raise ValueError('Dimension can only be 1 dimensional')
        new_dim = np.asarray(values, dtype=float).view(cls)
        new_dim._name = validate_single_string_arg(name, 'name')
        new_dim.quantity = quantity
        new_dim.units = units
        new_dim.dimension_type = dimension_type
        return new_dim

    def __array_finalize__(self, obj):
        # see InfoArray.__array_finalize__ for comments
        if obj is None:
            return
        self._name = validate_single_string_arg(getattr(obj, '_name', 'generic'), 'name')
        self.quantity = getattr(obj, '_quantity', 'generic')
        self.units = getattr(obj, '_units', 'generic')
        self.dimension_type = getattr(obj, '_dimension_type', 'UNKNOWN')

    def __array_wrap__(self, out_arr, context=None):
        # just call the parent
        super(Dimension, self).__array_wrap__(self, out_arr, context)
        # return correct values
        return out_arr

    def __repr__(self):
        return '{}:  {} ({}) of size {}'.format(self.name, self.quantity, self.units, self.shape)

    def __str__(self):
        return '{}:  {} ({}) of size {}'.format(self.name, self.quantity, self.units, self.shape)

    # def __copy__(self):
    #     new_dim = Dimension(np.array(self), name=self.name, quantity=self.quantity, units=self.units)
    #     new_dim.dimension_type = self.dimension_type
    #     return new_dim

    def __copy__(self):
        # Create a new instance of Dimension
        new_instance = Dimension(
            copy.copy(self.values),
            copy.copy(self.name),
            copy.copy(self.quantity),
            copy.copy(self.units),
            copy.copy(self.dimension_type)
        )

        return new_instance

    def __deepcopy__(self, memo):
        # For now this is what chatGPT came up with and it does not break any tests

        # Create a new instance of Dimension
        new_instance = Dimension(
            copy.deepcopy(self.values, memo),
            copy.deepcopy(self.name, memo),
            copy.deepcopy(self.quantity, memo),
            copy.deepcopy(self.units, memo),
            copy.deepcopy(self.dimension_type, memo)
        )

        return new_instance

    # TODO: Implement equality

    # TODO: Find out how to get rid of this
    def copy(self):
        # Not sure why __copy__() would not be called by itself
        new_dim = self.__copy__()
        return new_dim

    @property
    def info(self):
        return '{} - {} ({}): {}'.format(self.name, self.quantity, self.units,
                                         self.values)

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        raise AttributeError("Cannot change the name of the dimension. "
                             "If the dimension is associated with the dataset, please try "
                             "dataset.rename_dimension")

    #     # self._name = validate_single_string_arg(value, 'name')

    @property
    def quantity(self):
        return self._quantity

    @quantity.setter
    def quantity(self, value):
        self._quantity = validate_single_string_arg(value, 'quantity')

    @property
    def units(self):
        return self._units

    @units.setter
    def units(self, value):
        self._units = validate_single_string_arg(value, 'units')

    @property
    def dimension_type(self):
        return self._dimension_type

    @dimension_type.setter
    def dimension_type(self, value):
        if isinstance(value, DimensionType):
            self._dimension_type = value
        else:
            dimension_type = validate_single_string_arg(value, 'dimension_type')

            if dimension_type.upper() in [member.name for member in DimensionType]:
                self._dimension_type = DimensionType[dimension_type.upper()]
            elif dimension_type.lower() in ['frame', 'time', 'stack']:
                self._dimension_type = DimensionType.TEMPORAL
            else:
                self._dimension_type = DimensionType.UNKNOWN
                warn('Supported dimension types for plotting are only: {}'
                     ''.format([member.name for member in DimensionType]))
                warn('Setting DimensionType to UNKNOWN')

    @property
    def values(self):
        return np.array(self)

    # @values.setter
    # def values(self, value):
    #     isinstance(np.ndarray)

    def __eq__(self, other):
        if not isinstance(other, Dimension):
            return False
        if self.name != other.name:
            return False
        if self.units != other.units:
            return False
        if self.quantity != other.quantity:
            return False
        if len(self.values) != len(other):
            return False
        if not (np.array(self) == np.array(other)).all():
            return False
        if not (self.values == other.values).all():
            return False
        return True