r"""
Ambient lattices and ambient spaces
"""
from __future__ import absolute_import
#*****************************************************************************
#       Copyright (C) 2008-2009 Daniel Bump
#       Copyright (C) 2008-2013 Nicolas M. Thiery <nthiery at users.sf.net>
#
#  Distributed under the terms of the GNU General Public License (GPL)
#                  http://www.gnu.org/licenses/
#*****************************************************************************
from sage.misc.cachefunc import cached_method
from sage.combinat.free_module import CombinatorialFreeModule
from .weight_lattice_realizations import WeightLatticeRealizations
from sage.rings.all import ZZ, QQ
from sage.categories.homset import End

import six


class AmbientSpace(CombinatorialFreeModule):
    r"""
    Abstract class for ambient spaces

    All subclasses should implement a class method
    ``smallest_base_ring`` taking a Cartan type as input, and a method
    ``dimension`` working on a partially initialized instance with
    just ``root_system`` as attribute. There is no safe default
    implementation for the later, so none is provided.

    EXAMPLES::

        sage: AL = RootSystem(['A',2]).ambient_lattice()

    .. NOTE:: This is only used so far for finite root systems.

    Caveat: Most of the ambient spaces currently have a basis indexed
    by `0,\dots, n`, unlike the usual mathematical convention::

        sage: e = AL.basis()
        sage: e[0], e[1], e[2]
        ((1, 0, 0), (0, 1, 0), (0, 0, 1))

    This will be cleaned up!

    .. SEEALSO::

        - :class:`sage.combinat.root_system.type_A.AmbientSpace`
        - :class:`sage.combinat.root_system.type_B.AmbientSpace`
        - :class:`sage.combinat.root_system.type_C.AmbientSpace`
        - :class:`sage.combinat.root_system.type_D.AmbientSpace`
        - :class:`sage.combinat.root_system.type_E.AmbientSpace`
        - :class:`sage.combinat.root_system.type_F.AmbientSpace`
        - :class:`sage.combinat.root_system.type_G.AmbientSpace`
        - :class:`sage.combinat.root_system.type_dual.AmbientSpace`
        - :class:`sage.combinat.root_system.type_affine.AmbientSpace`

    TESTS::

        sage: types = CartanType.samples(crystallographic = True)+[CartanType(["A",2],["C",5])]
        sage: for e in [ct.root_system().ambient_space() for ct in types]:
        ....:          TestSuite(e).run()

        sage: e1 = RootSystem(['A',3]).ambient_lattice()
        sage: e2 = RootSystem(['B',3]).ambient_lattice()
        sage: e1 == e1
        True
        sage: e1 == e2
        False

        sage: e1 = RootSystem(['A',3]).ambient_space(QQ)
        sage: e2 = RootSystem(['A',3]).ambient_space(RR)
        sage: e1 == e2
        False
    """
    def __init__(self, root_system, base_ring, index_set=None):
        """
        EXAMPLES::

            sage: e = RootSystem(['A',3]).ambient_lattice()
            sage: s = e.simple_reflections()

            sage: L = RootSystem(['A',3]).coroot_lattice()
            sage: e.has_coerce_map_from(L)
            True
            sage: e(L.simple_root(1))
            (1, -1, 0, 0)
        """
        self.root_system = root_system
        if index_set is None:
            index_set = tuple(range(0, self.dimension()))
        CombinatorialFreeModule.__init__(self, base_ring,
                                         index_set,
                                         prefix='e',
                                         category = WeightLatticeRealizations(base_ring))
        coroot_lattice = self.root_system.coroot_lattice()
        coroot_lattice.module_morphism(self.simple_coroot, codomain=self).register_as_coercion()

        # FIXME: here for backward compatibility;
        # Should we use dimension everywhere?
        self.n = self.dimension()
        ct = root_system.cartan_type()
        if ct.is_irreducible() and ct.type() == 'E':
            self._v0 = self([0,0,0,0,0, 0,1, 1])
            self._v1 = self([0,0,0,0,0,-2,1,-1])


    def _test_norm_of_simple_roots(self, **options):
        """
        Tests that the norm of the roots is, up to an overal constant factor,
        given by the symmetrizer of the Cartan matrix.

        .. SEEALSO:: :class:`TestSuite`

        EXAMPLES::

            sage: e = RootSystem(['F',4]).ambient_space()
            sage: e._test_norm_of_simple_roots()
        """
        tester = self._tester(**options)
        T = self.cartan_type()
        D = T.symmetrizer()
        alpha = self.simple_roots()
        for C in T.dynkin_diagram().connected_components():
            tester.assertEquals(len( set( alpha[i].scalar(alpha[i]) / D[i] for i in C ) ), 1)

    # FIXME: attribute or method?
    def dimension(self):
        """
        Return the dimension of this ambient space.

        EXAMPLES::

            sage: from sage.combinat.root_system.ambient_space import AmbientSpace
            sage: e = RootSystem(['F',4]).ambient_space()
            sage: AmbientSpace.dimension(e)
            Traceback (most recent call last):
            ...
            NotImplementedError

        """
        raise NotImplementedError

    @classmethod
    def smallest_base_ring(cls, cartan_type=None):
        """
        Return the smallest ground ring over which the ambient space can be realized.

        This class method will get called with the Cartan type as
        input. This default implementation returns `\QQ`; subclasses
        should override it as appropriate.

        EXAMPLES::

            sage: e = RootSystem(['F',4]).ambient_space()
            sage: e.smallest_base_ring()
            Rational Field
        """
        return QQ

    def _repr_(self):
        """
        EXAMPLES::

            sage: RootSystem(['A',4]).ambient_lattice()    # indirect doctest
            Ambient lattice of the Root system of type ['A', 4]
            sage: RootSystem(['B',4]).ambient_space()
            Ambient space of the Root system of type ['B', 4]

        """
        return self._name_string()

    def _name_string(self, capitalize=True, base_ring=False, type=True):
        """
        EXAMPLES::

            sage: RootSystem(['A',4]).ambient_lattice()._name_string()
            "Ambient lattice of the Root system of type ['A', 4]"

        """
        return self._name_string_helper("ambient", capitalize=capitalize, base_ring=base_ring, type=type)

    def __call__(self, v):
        """
        TESTS::

            sage: R = RootSystem(['A',4]).ambient_lattice()
            sage: R([1,2,3,4,5])
            (1, 2, 3, 4, 5)
            sage: len(R([1,0,0,0,0]).monomial_coefficients())
            1
        """
        # This adds coercion from a list
        if isinstance(v, (list, tuple)):
            K = self.base_ring()
            return self._from_dict(dict((i,K(c)) for i,c in enumerate(v) if c))
        else:
            return CombinatorialFreeModule.__call__(self, v)


    def __getitem__(self,i):
        """
        Note that indexing starts at 1.

        EXAMPLES::

            sage: e = RootSystem(['A',2]).ambient_lattice()
            sage: e[1]
            (1, 0, 0)
            sage: e[0]
            Traceback (most recent call last):
            ...
            IndexError: value out of range
        """
        if not (i > 0 and i <= self.dimension()):
            raise IndexError("value out of range")
        return self.monomial(i-1)

    def coroot_lattice(self):
        """
        EXAMPLES::

            sage: e = RootSystem(["A", 3]).ambient_lattice()
            sage: e.coroot_lattice()
            Ambient lattice of the Root system of type ['A', 3]
        """
        return self

    def simple_coroot(self, i):
        r"""
        Returns the i-th simple coroot, as an element of this space

        EXAMPLES::

            sage: R = RootSystem(["A",3])
            sage: L = R.ambient_lattice()
            sage: L.simple_coroot(1)
            (1, -1, 0, 0)
            sage: L.simple_coroot(2)
            (0, 1, -1, 0)
            sage: L.simple_coroot(3)
            (0, 0, 1, -1)
        """
        return self.simple_root(i).associated_coroot()

    def reflection(self, root, coroot=None):
        """
        EXAMPLES::

            sage: e = RootSystem(["A", 3]).ambient_lattice()
            sage: a = e.simple_root(0); a
            (-1, 0, 0, 0)
            sage: b = e.simple_root(1); b
            (1, -1, 0, 0)
            sage: s_a = e.reflection(a)
            sage: s_a(b)
            (0, -1, 0, 0)

        """
        # TODO: get rid of this as one can use the generic implementation
        # (i.e. scalar and associated coroot are implemented)
        return lambda v: v - root.base_ring()(2*root.inner_product(v)/root.inner_product(root))*root

    @cached_method
    def fundamental_weight(self, i):
        """
        Returns the fundamental weight `\Lambda_i` in ``self``

        In several of the ambient spaces, it is more convenient to
        construct all fundamental weights at once. To support this, we
        provide this default implementation of ``fundamental_weight``
        using the method ``fundamental_weights``. Beware that this
        will cause a loop if neither ``fundamental_weight`` nor
        ``fundamental_weights`` is implemented.

        EXAMPLES::

            sage: e =  RootSystem(['F',4]).ambient_space()
            sage: e.fundamental_weight(3)
            (3/2, 1/2, 1/2, 1/2)

            sage: e =  RootSystem(['G',2]).ambient_space()
            sage: e.fundamental_weight(1)
            (1, 0, -1)

            sage: e =  RootSystem(['E',6]).ambient_space()
            sage: e.fundamental_weight(3)
            (-1/2, 1/2, 1/2, 1/2, 1/2, -5/6, -5/6, 5/6)
        """
        return self.fundamental_weights()[i]

    def from_vector_notation(self, weight, style="lattice"):
        """
        INPUT:

        - ``weight`` - a vector or tuple representing a weight

        Returns an element of self. If the weight lattice is not
        of full rank, it coerces it into the weight lattice, or
        its ambient space by orthogonal projection. This arises
        in two cases: for SL(r+1), the weight lattice is
        contained in a hyperplane of codimension one in the ambient,
        space, and for types E6 and E7, the weight lattice is
        contained in a subspace of codimensions 2 or 3, respectively.

        If style="coroots" and the data is a tuple of integers, it
        is assumed that the data represent a linear combination of
        fundamental weights. If style="coroots", and the root lattice
        is not of full rank in the ambient space, it is projected
        into the subspace corresponding to the semisimple derived group.
        This arises with Cartan type A, E6 and E7.

        EXAMPLES::

            sage: RootSystem("A2").ambient_space().from_vector_notation((1,0,0))
            (1, 0, 0)
            sage: RootSystem("A2").ambient_space().from_vector_notation([1,0,0])
            (1, 0, 0)
            sage: RootSystem("A2").ambient_space().from_vector_notation((1,0),style="coroots")
            (2/3, -1/3, -1/3)
        """
        if style == "coroots" and isinstance(weight, tuple) and all(xv in ZZ for xv in weight):
            weight = self.linear_combination(zip(self.fundamental_weights(), weight))

        x = self(weight)

        if style == "coroots":
            cartan_type = self.cartan_type()
            if cartan_type.is_irreducible() and cartan_type.type() == 'E':
                if cartan_type.rank() == 6:
                    x = x.coerce_to_e6()
                if cartan_type.rank() == 7:
                    x = x.coerce_to_e7()
            else:
                x = x.coerce_to_sl()
        return x

    def to_ambient_space_morphism(self):
        r"""
        Return the identity map on ``self``.

        This is present for uniformity of use; the corresponding method
        for abstract root and weight lattices/spaces, is not trivial.

        EXAMPLES::

            sage: P = RootSystem(['A',2]).ambient_space()
            sage: f = P.to_ambient_space_morphism()
            sage: p = P.an_element()
            sage: p
            (2, 2, 3)
            sage: f(p)
            (2, 2, 3)
            sage: f(p)==p
            True
        """
        return End(self).identity()

class AmbientSpaceElement(CombinatorialFreeModule.Element):
    # For backward compatibility
    def _repr_(self):
        """
        EXAMPLES::

            sage: e = RootSystem(['A',2]).ambient_space()
            sage: e.simple_root(0)    # indirect doctest
            (-1, 0, 0)
        """
        return str(self.to_vector())

    def inner_product(self, lambdacheck):
        """
        The scalar product with elements of the coroot lattice
        embedded in the ambient space.

        EXAMPLES::

            sage: e = RootSystem(['A',2]).ambient_space()
            sage: a = e.simple_root(0); a
            (-1, 0, 0)
            sage: a.inner_product(a)
            2
        """
        self_mc = self._monomial_coefficients
        lambdacheck_mc = lambdacheck._monomial_coefficients

        result = self.parent().base_ring().zero()
        for t,c in six.iteritems(lambdacheck_mc):
            if t not in self_mc:
                continue
            result += c*self_mc[t]
        return result

    scalar = inner_product
    dot_product = inner_product

    def associated_coroot(self):
        """
        EXAMPLES::

            sage: e = RootSystem(['F',4]).ambient_space()
            sage: a = e.simple_root(0); a
            (1/2, -1/2, -1/2, -1/2)
            sage: a.associated_coroot()
            (1, -1, -1, -1)

        """
        # FIXME: make it work over ZZ!
        return self * self.base_ring()(2/self.inner_product(self))

    def is_positive_root(self):
        """
        EXAMPLES::

            sage: R = RootSystem(['A',3]).ambient_space()
            sage: r=R.simple_root(1)+R.simple_root(2)
            sage: r.is_positive_root()
            True
            sage: r=R.simple_root(1)-R.simple_root(2)
            sage: r.is_positive_root()
            False
        """
        return self.parent().rho().scalar(self) > 0

    def coerce_to_sl(self):
        """
        For type ['A',r], this coerces the element of the ambient space into the
        root space by orthogonal projection. The root space has codimension one
        and corresponds to the Lie algebra of SL(r+1,CC), whereas the full weight
        space corresponds to the Lie algebra of GL(r+1,CC). So this operation
        corresponds to multiplication by a (possibly fractional) power of the
        determinant to give a weight determinant one.

        EXAMPLES::

            sage: [fw.coerce_to_sl() for fw in RootSystem("A2").ambient_space().fundamental_weights()]
            [(2/3, -1/3, -1/3), (1/3, 1/3, -2/3)]
            sage: L = RootSystem("A2xA3").ambient_space()
            sage: L([1,2,3,4,5,0,0]).coerce_to_sl()
            (-1, 0, 1, 7/4, 11/4, -9/4, -9/4)
        """
        cartan_type = self.parent().cartan_type()
        x = self
        if cartan_type.is_atomic():
            if cartan_type.type() == 'A':
                x = x - self.parent().det(sum(x.to_vector())/(self.parent().dimension()))
        else:
            xv = x.to_vector()
            shifts = cartan_type._shifts
            types = cartan_type.component_types()
            for i in range(len(types)):
                if cartan_type.component_types()[i][0] == 'A':
                    s = self.parent().ambient_spaces()[i].det(sum(xv[shifts[i]:shifts[i+1]])/(types[i][1]+1))
                    x = x - self.parent().inject_weights(i, s)
        return x

    def coerce_to_e7(self):
        """
        For type E8, this orthogonally projects the given element of
        the E8 root lattice into the E7 root lattice. This operation on
        weights corresponds to intersection with the semisimple subgroup E7.

        EXAMPLES::

            sage: [b.coerce_to_e7() for b in RootSystem("E8").ambient_space().basis()]
            [(1, 0, 0, 0, 0, 0, 0, 0), (0, 1, 0, 0, 0, 0, 0, 0),
             (0, 0, 1, 0, 0, 0, 0, 0), (0, 0, 0, 1, 0, 0, 0, 0),
             (0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 0, 0, 0, 1, 0, 0),
             (0, 0, 0, 0, 0, 0, 1/2, -1/2), (0, 0, 0, 0, 0, 0, -1/2, 1/2)]
        """
        x = self
        v0 = self.parent()._v0
        ret = x - (x.inner_product(v0)/2)*v0
        return ret

    def coerce_to_e6(self):
        """
        For type E7 or E8, orthogonally projects an element of the root lattice
        into the E6 root lattice. This operation on weights corresponds to
        intersection with the semisimple subgroup E6.

        EXAMPLES::

            sage: [b.coerce_to_e6() for b in RootSystem("E8").ambient_space().basis()]
            [(1, 0, 0, 0, 0, 0, 0, 0), (0, 1, 0, 0, 0, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0),
            (0, 0, 0, 1, 0, 0, 0, 0), (0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 0, 0, 0, 1/3, 1/3, -1/3),
            (0, 0, 0, 0, 0, 1/3, 1/3, -1/3), (0, 0, 0, 0, 0, -1/3, -1/3, 1/3)]
        """
        x = self
        v0 = self.parent()._v0
        v1 = self.parent()._v1
        x = x - (x.inner_product(v0)/2)*v0
        return  x - (x.inner_product(v1)/6)*v1

    def to_ambient(self):
        r"""
        Map ``self`` to the ambient space.

        This exists for uniformity. Its analogue for root and weight lattice realizations,
        is not trivial.

        EXAMPLES::

            sage: v = CartanType(['C',3]).root_system().ambient_space().an_element(); v
            (2, 2, 3)
            sage: v.to_ambient()
            (2, 2, 3)

        """
        return self

AmbientSpace.Element = AmbientSpaceElement

