# -*- coding: utf-8 -*-
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
import numpy as np
from ...ext.six import string_types
from .shader_object import ShaderObject

VARIABLE_TYPES = ('const', 'uniform', 'attribute', 'varying', 'inout')


class Variable(ShaderObject):
    """ Representation of global shader variable
    
    Parameters
    ----------
    name : str
        the name of the variable. This string can also contain the full
        definition of the variable, e.g. 'uniform vec2 foo'.
    value : {float, int, tuple, GLObject}
        If given, vtype and dtype are determined automatically. If a
        float/int/tuple is given, the variable is a uniform. If a gloo
        object is given that has a glsl_type property, the variable is
        an attribute and
    vtype : {'const', 'uniform', 'attribute', 'varying', 'inout'}
        The type of variable.
    dtype : str
        The data type of the variable, e.g. 'float', 'vec4', 'mat', etc.
    
    """
    
    _vtype_32_conversion = {'in': 'attribute', 'out': 'varying'}
    _vtype_23_conversion = {'attribute': 'in', 'varying': 'out'}
    
    def __init__(self, name, value=None, vtype=None, dtype=None):
        super(Variable, self).__init__()
        
        # allow full definition in first argument
        if ' ' in name:
            fields = name.split(' ')
            if len(fields) == 3:
                vtype, dtype, name = fields
            elif len(fields) == 4 and fields[0] == 'const':
                vtype, dtype, name, value = fields
            else:
                raise ValueError('Variable specifications given by string must'
                                 ' be of the form "vtype dtype name" or '
                                 '"const dtype name value".')
            
        if not (isinstance(name, string_types) or name is None):
            raise TypeError("Variable name must be string or None.")
        
        self._state_counter = 0
        self._name = name
        self._vtype = self._vtype_32_conversion.get(vtype, vtype)
        self._dtype = dtype
        self._value = None
        
        # If vtype/dtype were given at init, then we will never
        # try to set these values automatically.
        self._type_locked = self._vtype is not None and self._dtype is not None
            
        if value is not None:
            self.value = value
        
        if self._vtype and self._vtype not in VARIABLE_TYPES:
            raise ValueError('Not a valid vtype: %r' % self._vtype)
    
    @property
    def name(self):
        """ The name of this variable.
        """
        return self._name
    
    @name.setter
    def name(self, n):
        # Settable mostly to allow automatic setting of varying names 
        # See ShaderObject.create()
        if self._name != n:
            self._name = n
            self.changed(code_changed=True)
    
    @property
    def vtype(self):
        """ The type of variable (const, uniform, attribute, or varying).
        
        For in/out variables (GLSL 150+), vtype is 'varying'.
        """
        return self._vtype
    
    @property
    def dtype(self):
        """ The type of data (float, int, vec, mat, ...).
        """
        return self._dtype
    
    @property
    def value(self):
        """ The value associated with this variable.
        """
        return self._value
    
    @value.setter
    def value(self, value):
        if isinstance(value, (tuple, list)) and 1 < len(value) < 5:
            vtype = 'uniform'
            dtype = 'vec%d' % len(value)
        elif isinstance(value, np.ndarray):
            if value.ndim == 1 and (1 < len(value) < 5):
                vtype = 'uniform'
                dtype = 'vec%d' % len(value)
            elif value.ndim == 2 and value.shape in ((2, 2), (3, 3), (4, 4)):
                vtype = 'uniform'
                dtype = 'mat%d' % value.shape[0]                
            else:
                raise ValueError("Cannot make uniform value for %s from array "
                                 "of shape %s." % (self.name, value.shape))
        elif np.isscalar(value):
            vtype = 'uniform'
            if isinstance(value, (float, np.floating)):
                dtype = 'float'
            elif isinstance(value, (int, np.integer)):
                dtype = 'int'
            else:
                raise TypeError("Unknown data type %r for variable %r" % 
                                (type(value), self))
        elif getattr(value, 'glsl_type', None) is not None:
            # Note: hasattr() is broken by design--swallows all exceptions!
            vtype, dtype = value.glsl_type
        else:
            raise TypeError("Unknown data type %r for variable %r" % 
                            (type(value), self))

        self._value = value
        self._state_counter += 1
        
        if self._type_locked:
            if dtype != self._dtype or vtype != self._vtype:
                raise TypeError('Variable is type "%s"; cannot assign value '
                                '%r.' % (self.dtype, value))
            return
            
        # update vtype/dtype and emit changed event if necessary
        changed = False
        if self._dtype != dtype:
            self._dtype = dtype
            changed = True
        if self._vtype != vtype:
            self._vtype = vtype
            changed = True
        if changed:
            self.changed(code_changed=True, value_changed=True)
    
    @property
    def state_id(self):
        """Return a unique ID that changes whenever the state of the Variable
        has changed. This allows ModularProgram to quickly determine whether
        the value has changed since it was last used."""
        return id(self), self._state_counter

    def __repr__(self):
        return ("<%s \"%s %s %s\" at 0x%x>" % (self.__class__.__name__,
                                               self._vtype, self._dtype, 
                                               self.name, id(self)))
    
    def expression(self, names):
        return names[self]

    def _vtype_for_version(self, version):
        """Return the vtype for this variable, converted based on the GLSL
        version.
        """
        vtype = self.vtype
        if version is None or version[0] == 120:
            return self._vtype_32_conversion.get(vtype, vtype) 
        else:
            return self._vtype_23_conversion.get(vtype, vtype) 

    def definition(self, names, version, shader):
        if self.vtype is None:
            raise RuntimeError("Variable has no vtype: %r" % self)
        if self.dtype is None:
            raise RuntimeError("Variable has no dtype: %r" % self)
        
        name = names[self]
        vtype = self._vtype_for_version(version)
        if vtype == 'const':
            return '%s %s %s = %s;' % (vtype, self.dtype, name, self.value)
        else:
            return '%s %s %s;' % (vtype, self.dtype, name)


class Varying(Variable):
    """ Representation of a varying (variables passed from one shader to the
    next).
    
    Varyings can inherit their dtype from another Variable, allowing for
    more flexibility in composing shaders.
    """
    def __init__(self, name, dtype=None):
        self._link = None
        self._src_func = None
        self._dst_func = None
        Variable.__init__(self, name, vtype='varying', dtype=dtype)
        
    @property
    def value(self):
        """ The value associated with this variable.
        """
        return self._value
    
    @value.setter
    def value(self, value):
        if value is not None:
            raise TypeError("Cannot assign value directly to varying.")
    
    @property
    def dtype(self):
        if self._dtype is None:
            if self._link is None:
                return None
            else:
                return self._link.dtype
        else:
            return self._dtype

    def link(self, var):
        """ Link this Varying to another object from which it will derive its
        dtype. 
        
        This method is used internally when assigning an attribute to
        a varying using syntax ``function[varying] = attr``.
        """
        assert self._dtype is not None or hasattr(var, 'dtype')
        self._link = var
        self.changed()

    def invar(self, array=False):
        """Return a varying that defines itself using the same name as this,
        but as an `in` variable instead of `out`.
        """
        return InVar(self, array=array)
    
    
class InVar(Variable):
    def __init__(self, var, array=False):
        self._var = var
        self._array = array
        Variable.__init__(self, var.name)

    @property
    def value(self):
        """ The value associated with this variable.
        """
        return self._var.value
    
    @value.setter
    def value(self, value):
        if value is not None:
            raise TypeError("Cannot assign value directly to varying.")
    
    @property
    def dtype(self):
        return self._var.dtype

    def definition(self, names, version, shader):
        # inherit name from source variable
        name = names[self._var]
        dtype = self._var.dtype
        
        if version[0] <= 120:
            return "varying %s %s;" % (dtype, name)
        else:
            if self._array:
                return "in %s %s[];" % (dtype, name)
            else:
                return "in %s %s;" % (dtype, name)
        
    def expression(self, names):
        return names[self._var]