import Base: ×

export DirectProductGroup, DirectProductGroupElem

###############################################################################
#
#   DirectProductGroup / DirectProductGroupElem
#
###############################################################################

doc"""
   DirectProductGroup(G::Group, n::Int) <: Group
Implements `n`-fold direct product of `G`. The group operation is
`*` distributed component-wise, with component-wise identity as neutral element.
"""

immutable DirectProductGroup{T<:Group} <: Group
   group::T
   n::Int
end

immutable DirectProductGroupElem{T<:GroupElem} <: GroupElem
   elts::Vector{T}
end

###############################################################################
#
#   Type and parent object methods
#
###############################################################################

elem_type{T<:Group}(G::DirectProductGroup{T}) =
   DirectProductGroupElem{elem_type(G.group)}

parent_type{T<:GroupElem}(::Type{DirectProductGroupElem{T}}) =
   DirectProductGroup{parent_type(T)}

parent(g::DirectProductGroupElem) =
   DirectProductGroup(parent(first(g.elts)), length(g.elts))

###############################################################################
#
#   AbstractVector interface
#
###############################################################################

Base.size(g::DirectProductGroupElem) = size(g.elts)
Base.linearindexing(::Type{DirectProductGroupElem}) = Base.LinearFast()
Base.getindex(g::DirectProductGroupElem, i::Int) = g.elts[i]
function Base.setindex!{T<:GroupElem}(g::DirectProductGroupElem{T}, v::T, i::Int)
   p.part[i] = v
   return p
end

###############################################################################
#
#   DirectProductGroup / DirectProductGroupElem constructors
#
###############################################################################

function ×(G::Group, H::Group)
   G == H || throw("Direct products are defined only for the same groups")
   return DirectProductGroup(G,2)
end

###############################################################################
#
#   Parent object call overloads
#
###############################################################################

doc"""
    (G::DirectProductGroup)(a::Vector, check::Bool=true)
> Constructs element of the $n$-fold direct product group `G` by coercing each
> element of vector `a` to `G.group`. If `check` flag is set to `false` no
> checks on the correctness are performed.
"""
function (G::DirectProductGroup)(a::Vector, check::Bool=true)
   if check
      G.n == length(a) || throw("Can not coerce to DirectProductGroup: lengths differ")
      a = G.group.(a)
   end
   return DirectProductGroupElem(a)
end

(G::DirectProductGroup)() = DirectProductGroupElem([G.group() for _ in 1:G.n])

(G::DirectProductGroup)(g::DirectProductGroupElem) = G(g.elts)

(G::DirectProductGroup){T<:GroupElem, N}(a::Vararg{T, N}) = G([a...])

###############################################################################
#
#   Basic manipulation
#
###############################################################################

function deepcopy_internal(g::DirectProductGroupElem, dict::ObjectIdDict)
   G = parent(g)
   return G(deepcopy(g.elts))
end

function hash(G::DirectProductGroup, h::UInt)
   return hash(G.group, hash(G.n, hash(DirectProductGroup,h)))
end

function hash(g::DirectProductGroupElem, h::UInt)
   return hash(g.elts, hash(parent(g), hash(DirectProductGroupElem, h)))
end

doc"""
    eye(G::DirectProductGroup)
> Return the identity element for the given direct product of groups.

"""
eye(G::DirectProductGroup) = G()

###############################################################################
#
#   String I/O
#
###############################################################################

function show(io::IO, G::DirectProductGroup)
    println(io, "$(G.n)-fold direct product of $(G.group)")
end

function show(io::IO, g::DirectProductGroupElem)
    print(io, "($(join(g.elts,",")))")
end

###############################################################################
#
#   Comparison
#
###############################################################################

doc"""
    ==(g::DirectProductGroup, h::DirectProductGroup)
> Checks if two direct product groups are the same.
"""
function (==)(G::DirectProductGroup, H::DirectProductGroup)
    G.group == H.group || return false
    G.n == G.n || return false
    return true
end

doc"""
    ==(g::DirectProductGroupElem, h::DirectProductGroupElem)
> Checks if two direct product group elements are the same.
"""
function (==)(g::DirectProductGroupElem, h::DirectProductGroupElem)
    parent(g) == parent(h) || return false
    g.elts == h.elts || return false
    return true
end

###############################################################################
#
#   Binary operators
#
###############################################################################

function direct_mult(g::DirectProductGroupElem, h::DirectProductGroupElem)
   G = parent(g)
   # G == parent(h) || throw("Can't multiply elements from different groups: $G, $parent(h)")
   if isa(first(G.factors), Ring)
      return G(.+(g.elts,h.elts))
   else
      return G(.*(g.elts,h.elts))
   end
end

doc"""
    *(g::DirectProductGroupElem, h::DirectProductGroupElem)
> Return the direct-product group operation of elements, i.e. component-wise
> operation as defined by `operations` field of the parent object.

"""
(*)(g::DirectProductGroupElem, h::DirectProductGroupElem) = direct_mult(g,h)

###############################################################################
#
#   Inversion
#
###############################################################################

doc"""
    inv(g::DirectProductGroupElem)
> Return the inverse of the given element in the direct product group.

"""
# TODO: dirty hack around `+` operation
function inv(g::DirectProductGroupElem)
    G = parent(g)
   if isa(first(G.factors), Ring)
      return DirectProductGroupElem([-a for a in g.elts])
   else
      return DirectProductGroupElem([inv(a) for a in g.elts])
   end
end

###############################################################################
#
#   Misc
#
###############################################################################

doc"""
    elements(G::DirectProductGroup)
> Returns `Task` that produces all elements of group `G` (provided that factors
> implement the elements function).

"""
# TODO: can Base.product handle generators?
#   now it returns nothing's so we have to collect ellements...
function elements(G::DirectProductGroup)
    cartesian_prod = Base.product([collect(elements(H)) for H in G.factors]...)
    return (G(collect(elt)) for elt in cartesian_prod)
end

doc"""
    order(G::DirectProductGroup)
> Returns the order (number of elements) in the group.

"""
order(G::DirectProductGroup) = prod([order(H) for H in G.factors])