abstract type Region end
struct Interior <: Region end
struct Lower    <: Region end
struct Upper    <: Region end

struct StencilIndex{R<:Region, T<:Integer}
    localindex::CartesianIndex
    globalindex::T

    StencilIndex{R}(li::CartesianIndex, gi::T) where {R<:Region,T<:Integer} = new{R, T}(li, gi)
    StencilIndex(li::CartesianIndex, gi::T, ::Type{R}) where {R<:Region,T<:Integer} = StencilIndex{R}(li, gi)

    # Index(t::Tuple{T, Type{R}}) where {R<:Region,T<:Integer} = Index{t[2]}(t[1])
    # Above doesn't work, below does but is less type strict
    #Index(t::Tuple{T, DataType}) where {R<:Region,T<:Integer} = Index{t[2]}(t[1])
end

function Base.getindex(si::StencilIndex, i::Int)
     return si.localindex[i]
end

#Index(t::Vararg{Tuple{T, DataType}}) where T = Index.(t)
# TODO: Where to place this function?

function stencilindices(diffOp)
    N = diffOp.grid.numberOfPointsPerDim

    lowerclosure = Vector{Vector{StencilIndex{Lower, Int64}}}(undef,0)
    upperclosure = Vector{Vector{StencilIndex{Upper, Int64}}}(undef,0)
    interior = Vector{Vector{StencilIndex{Interior, Int64}}}(undef,0)
    cSize = closureSize(diffOp.op)
    ci = CartesianIndices(diffOp.grid.numberOfPointsPerDim)

    # TODO: Loop over all points or one loop for each region?
    for j = 1:Grid.numberOfDimensions(diffOp.grid)
        templ = Vector{StencilIndex{Lower,Int64}}(undef, 0)
        tempu = Vector{StencilIndex{Upper,Int64}}(undef, 0)
        tempi = Vector{StencilIndex{Interior,Int64}}(undef, 0)
        for i ∈ 1:Grid.numberOfPoints(diffOp.grid)
            val = ci[i][j]
            if val ∈ range(1; length=cSize)
                push!(templ, StencilIndex{Lower}(ci[i],i))
            elseif val ∈ range(N[j] - cSize+1, length=cSize)
                push!(tempu, StencilIndex{Upper}(ci[i],i))
            else
                push!(tempi, StencilIndex{Interior}(ci[i],i))
            end
        end
        push!(lowerclosure,templ)
        push!(upperclosure,tempu)
        push!(interior,tempi)
    end
    return lowerclosure, upperclosure, interior
end