/** Neuroevolution.

   See_Also: https://en.wikipedia.org/wiki/Neuroevolution

   TODO Profile use of cellops and logops in a specific domain or pattern och
   and use roulette wheel sampling based on these in future patterns.

   TODO reuse bit_traits.packedBitSizeOf

   TODO reuse `IndexedBy` `Cells` and `CellIx`
*/
module nxt.nevo;

@safe pure:

/** Low-Level (Genetic Programming) Operation Network Node Types often implemented
    in a modern hardware (CPU/GPU).

    See_Also: http://llvm.org/docs/LangRef.html#typesystem
    See_Also: http://llvm.org/docs/LangRef.html#instref
*/
enum Lop
{
    summ,                       /// Sum.
    prod,                       /// Product.
    emin,                       /// Mininum.
    emax                        /// Maximum.
}

/** Obselete.
*/
enum LOPobseleted
{
    id, /**< Identity. */

    /* \name arithmetical: additive */
    /* @{ */
    add,                      /**< add (mi1o) */
    sub,                      /**< subtract (mi1o) */
    neg,                      /**< negation (1i1o) */
    /* @} */

    /* \name arithmetical: multiplicative */
    /* @{ */
    mul,                      /**< multiply (mimo) */
    div,                      /**< divide (mi1o) */
    pow,                      /**< power (2i1o) */
    inv,                      /**< inverse (1i1o) */
    /* @} */

    /* \name Harmonic */
    /* @{ */
    sin,                      /**< sine (1i1o) */
    cos,                      /**< cosine (1i1o) */
    tan,                      /**< tangens (1i1o) */

    /* \name Inverse Harmonic */
    csc,                      /**< 1/sin(a) */
    cot,                      /**< cotangens (1i1o) */
    sec,                      /**< 1/cos(a) */

    // Arcus
    acos,                     /**< arcus cosine (1i1o) */
    asin,                     /**< arcus sine (1i1o) */
    atan,                     /**< arcus tanges (1t2i1o) */
    acot,                     /**< arcus cotangens (1i1o) */
    acsc,                     /**< arcus css (1i1o) */
    /* @} */

    /* \name hyperbolic */
    /* @{ */
    cosh, sinh, tanh, coth, csch,
    acosh, asinh, atanh, acoth, acsch,
    /* @} */

    // /* \name imaginary numbers */
    // /* @{ */
    // real, imag, conj,
    // /* @} */

    /* \name reorganizer/permutators/permutations */
    /* @{ */
    identity,                 /**< identity (copy) (1imo) */
    interleave,               /**< interleave (1imo) */
    flip,                     /**< flip (1i1o) */
    mirror,                   /**< mirror (1i1o) */
    shuffle,                  /**< shuffle (1i1o) */
    /* @} */

    /* \name generators */
    /* @{ */
    ramp,                     /**< linear ramp (2imo) */
    zeros,                    /**< zeros (0imo) */
    ones,                     /**< ones (0imo) */
    rand,                     /**< ranodm (0imo) */
    /* @} */

    /* \name comparison */
    /* @{ */
    eq,                       /**< equality (mi1o) */
    neq,                      /**< non-equality (mi1o) */
    lt,                       /**< less-than (2i1o) */
    lte,                      /**< less-than or equal (2i1o) */
    gt,                       /**< greater-than (2i1o) */
    gte,                      /**< greater-than or equal (2i1o) */
    /* @} */

    /* \name logical */
    /* @{ */
    all,                      /**< all (non-zero) (mi1o) */
    any,                      /**< any (non-zero) (mi1o) */
    none,                     /**< none (zero) (mi1o) */
    /* @} */
}

version(none)
{
/** Return non-zero if \p lop is an \em Arithmetical \em Additive Operation. */
bool isAdd(Lop lop)
{
    return (lop == Lop.add ||
            lop == Lop.sub ||
            lop == Lop.neg);
}

/** Return non-zero if \p lop is an \em Arithmetical \em Additive Operation. */
bool isMul(Lop lop)
{
    return (lop == Lop.mul ||
            lop == Lop.div ||
            lop == Lop.pow ||
            lop == Lop.inv);
}

bool isArithmetic(Lop lop)
{
    return isAdd(lop) && isArithmetic(lop);
}

/** Return non-zero if \p lop is an \em Trigonometric Operation. */
bool isTrigonometric(Lop lop)
{
    return (lop == Lop.cos ||
            lop == Lop.sin ||
            lop == Lop.tan ||
            lop == Lop.cot ||
            lop == Lop.csc ||
            lop == Lop.acos ||
            lop == Lop.asin ||
            lop == Lop.atan ||
            lop == Lop.acot ||
            lop == Lop.acsc
        );
}

/** Return non-zero if \p lop is an \em Hyperbolic Operation. */
bool isHyperbolic(Lop lop)
{
    return (lop == Lop.cosh ||
            lop == Lop.sinh ||
            lop == Lop.tanh ||
            lop == Lop.coth ||
            lop == Lop.csch ||
            lop == Lop.acosh ||
            lop == Lop.asinh ||
            lop == Lop.atanh ||
            lop == Lop.acoth ||
            lop == Lop.acsch);
}

/** Return non-zero if \p lop is a \em Generator Operation. */
bool isGen(Lop lop)
{
    return (lop == Lop.ramp ||
            lop == Lop.zeros ||
            lop == Lop.ones ||
            lop == Lop.rand);
}

/** Return non-zero if \p lop is a \em Comparison Operation. */
bool isCmp(Lop lop)
{
    return (lop == Lop.eq ||
            lop == Lop.neq ||
            lop == Lop.lt ||
            lop == Lop.lte ||
            lop == Lop.gt ||
            lop == Lop.gte);
}

/** Return non-zero if \p lop is a \em Permutation/Reordering Operation. */
bool isPermutation(Lop lop)
{
    return (lop == Lop.identity ||
            lop == Lop.interleave ||
            lop == Lop.flip ||
            lop == Lop.mirror ||
            lop == Lop.shuffle);
}
}

/// Cell Operation.
enum CellOp
{
    seqClone,                   /// sequential clone
    parClone,                   /// parallel clone
}
alias CellOps = Owned!(DynamicArray!CellOp); // TODO bit-pack

/**m Network (Transformation) Operation Type Code.
 *
 * Instructions for a Program that builds \em Computing Networks (for
 * example Artificial Nerual Networks ANN).
 *
 * TODO What does \em nature cell this information bearer: Closest I
 * have found is http://en.wikipedia.org/wiki/Allele.
 */
enum Gop
{
    /* \name Structural: Inter-Node */
    /* @{ */
    seq,                    /**< Sequential Growth. Inherit Initial Value. Set weight to +1. State is \em ON. */
    par,                    /**< Parallel Growth */

    clone,                  /**< Clone. Like \c PAR but  */
    /* @} */

    /* \name Local: Intra-Node */
    /* @{ */
    setLOp,                /**< Set Node Logic Operation (see \c Lop). */

    setOType, /**< Set Out-Type. Either \c int, \c float or \c double for now. */

    incBias,               /**< Increase Threshold */
    decBias,               /**< Decrease Threshold */

    /* There is \em no need for "in-precision", since these are the same
       as in-precision the "previous" nodes in the network. */
    incOpRec,              /**< Increase Out-Precision */
    decOpRec,              /**< Decrease Out-Precision */

    incLinkreg,            /**< Increase In-Link-Register */
    decLinkreg,            /**< Decrease In-Link-Register */

    on,                     /**< \em Activate Current In-Link. */
    off,                    /**< \em Deactivate Current In-Link. */

    /* @} */

    wait,                   /**< Wait (Delay) one clock-cycle? */
    rec,                    /**< \em Recurse up to top (decreasing life with one). */

    jmp,                    /**< \em Jump to sub-Network/Procedure/Function. */
    def,                    /**< \em Define sub-Network/Procedure/Function. */

    end,                    /**< \em Recursion Terminator in serialized code (stream of t's). */
    null_,                   /**< \em Network Terminator in serialized code (stream of t's). */
}

// wchar
// wchar_from_LOP(Lop lop)
// {
//     wchar_t wc = UNICODE_UNKNOWN;
//     switch (lop) {
//     case Lop.add: wc = UNICODE_CIRCLED_PLUS; break;
//     case Lop.sub: wc = UNICODE_CIRCLED_MINUS; break;
//     case Lop.neg: wc = UNICODE_SQUARED_MINUS; break;
//     case Lop.mul: wc = UNICODE_CIRCLED_TIMES; break;
//     case Lop.div: wc = UNICODE_CIRCLED_DIVISION_SLASH; break;
//     case Lop.pow: wc = UNICODE_UNKNOWN; break;
//     case Lop.inv: wc = UNICODE_CIRCLED_DIVISION_SLASH; break;
//     default: break;
//     }
//     return wc;
// }

import std.bitmanip : BitArray;
import std.random : Random, uniform;

import nxt.dynamic_array : DynamicArray;
import nxt.dynamic_array : DynamicArray;

import nxt.typecons_ex : IndexedBy;
import nxt.owned : Owned;

import nxt.variant : FastAlgebraic;

alias Data = FastAlgebraic!(long, double);
alias Datas = Owned!(DynamicArray!Data);

/// Scalar Operation Count.
alias OpCount = size_t;

/// Relative Cell index.
alias CellRIx = ptrdiff_t;

/// Relative Cell indexs.
alias CellRIxs = Owned!(DynamicArray!CellRIx);

/// Calculating Cell.
struct Cell
{
    import std.algorithm.iteration : map, filter, fold;

    @safe pure:

    this(Lop lop, size_t inputRIxsLength, size_t cellCount)
    {
    }

    /// Randomize a cell.
    void randomize(Lop lop, size_t inputRIxsLength, size_t cellCount) @trusted
    {
        auto gen = Random();
        this.lop = lop;

        // TODO use std.algorithm to fill in `inputCellRIxs`
        inputCellRIxs.length = inputRIxsLength;
        foreach (ref rix; inputCellRIxs[])
        {
            rix = uniform(cast(CellRIx)0, cast(CellRIx)cellCount/10, gen);
        }
    }

    nothrow:

    OpCount execute(const ref Datas ins, ref Datas outs) const
    {
        if (ins.empty) { return typeof(return).init; }
        final switch (lop)
        {
        case Lop.summ: return summ(ins, outs);
        case Lop.prod: return prod(ins, outs);
        case Lop.emin: return emin(ins, outs);
        case Lop.emax: return emax(ins, outs);
        }
    }

    /// Sum of `ins`.
    OpCount summ(const ref Datas ins, ref Datas outs) const @trusted
    {
        import std.algorithm.iteration : sum;
        outs.length = 1;
        outs[0] = ins[].filter!(_ => _.hasValue)
                       .map!(_ => _.commonValue)
                       .sum();
        return ins.length - 1;
    }

    /// Product of `ins`.
    OpCount prod(const ref Datas ins, ref Datas outs) const @trusted
    {
        outs.length = 1;
        outs[0] = ins[].filter!(_ => _.hasValue)
                       .map!(_ => _.commonValue)
                       .fold!((a, b) => a * b)(cast(Data.CommonType)1.0);
        return ins.length - 1;
    }

    /// Minimum of `ins`.
    OpCount emin(const ref Datas ins, ref Datas outs) const @trusted
    {
        import std.algorithm : minElement;
        outs.length = 1;
        outs[0] = ins[].filter!(_ => _.hasValue)
                       .map!(_ => _.commonValue)
                       .minElement(+Data.CommonType.max);
        return ins.length - 1;
    }

    /// Maximum of `ins`.
    OpCount emax(const ref Datas ins, ref Datas outs) const @trusted
    {
        import std.algorithm : maxElement;
        outs.length = 1;
        outs[0] = ins[].filter!(_ => _.hasValue)
                       .map!(_ => _.commonValue)
                       .maxElement(-Data.CommonType.max);
        return ins.length - 1;
    }

    Lop lop;                  /// operation
    CellRIxs inputCellRIxs;   /// relative indexes to (neighbouring) input cells
}
alias Cells = IndexedBy!(Owned!(DynamicArray!Cell), `Ix`);

/// Network/Graph of `Cells`.
struct Network
{
    @safe pure /*TODO nothrow @nogc*/:

    this(size_t cellCount)
    {
        auto gen = Random();

        cells.reserve(cellCount);
        temps.reserve(cellCount);

        foreach (immutable i; 0 .. cellCount)
        {
            cells ~= Cell(gen.uniform!Lop, 10, cellCount);
            temps ~= Data(gen.uniform!long);
        }
    }

    /// One step forward.
    OpCount step() @trusted
    {
        typeof(return) opCount = 0;

        foreach (immutable i, ref cell; cells)
        {
            Datas ins;
            ins.reserve(cell.inputCellRIxs.length);
            foreach (immutable rix; cell.inputCellRIxs)
            {
                ins ~= temps[(i + rix) % cells.length]; // relative index
            }

            Datas tempOuts;         // data to be filled
            if (immutable opCount_ = cell.execute(ins, tempOuts))
            {
                opCount += opCount_;
                temps[i] = tempOuts[0];
            }
        }
        return opCount;
    }

    BitArray pack() nothrow @nogc
    {
        typeof(return) bits;
        return bits;
    }

    static typeof(this) unpack(in BitArray bits) nothrow @nogc
    {
        typeof(this) that;
        return that;
    }

    Cells cells;                /// operation/function cells
    Datas temps;                /// temporary outputs from cells
}

/// Generative Code.
struct Code
{
    @safe pure nothrow:

    CellOps cellOps; // cell operations, an indirect generative network encoding
    alias cellOps this;

    Cells.Ix writerIxs;         /// index to writers

    Network generate() const
    {
        typeof(return) network;
        foreach (immutable cellOp; cellOps[])
        {
        }
        return network;
    }
}

unittest
{
    immutable cellCount = 1_000;
    auto task = Network(cellCount);

    immutable stepCount = 1_0;
    foreach (immutable i; 0 .. stepCount)
    {
        task.step();
    }

    // dbg("DONE");
}