module sily.meta;
package(sily) {
    import std.array;
    import std.string;
    import std.algorithm;


    // for my sanity or for sanity of anyone who's seeing this
    // is(typeof(A + B)) is basically a check if two types
    // are compatible together.
    // so 0 + "A" will return false, but 0 + true will return true
    bool isValidOp(string op, T, R, E = T)() pure {
        mixin(`return is( typeof( mixin("T.init"` ~ op ~ `"R.init" ) ): E );`);
    }

    /* -------------------------------------------------------------------------- */
    /*                     LOTS OF STUFF IS PULLED FROM HERE:                     */
    /*          HTTPS://GITHUB.COM/DEXSET/DESCORE/TREE/MASTER/IMPORT/DES          */
    /*           TBH THIS WHOLE FILE IS FROM THIS REPO EXCEPT ISVALIDOP           */
    /*          BUT IT WORKS AND I DON'T EVEN WANT TO TRY TO UNDERSTAND           */
    /*                           WHAT IS GOING ON HERE                            */
    /* -------------------------------------------------------------------------- */

        
    // used as:
    //
    // static if (N == 2 || N == 3 || N == 4) {
    //     static if (N == 2) enum AccessString = "x y|w h|u v";
    //     else
    //     static if (N == 3) enum AccessString = "x y z|w h d|u v t|r g b";
    //     else
    //     static if (N == 4) enum AccessString = "x y z w|r g b a";

    //     mixin accessByString!(N, T, "data", AccessString);
    // }

    mixin template accessByString( T, size_t N, string data, string AS, string VVASES=" ", string VVASVS="|")
        if( isCompatibleArrayAccessStrings(N,AS,VVASES,VVASVS) ) {
        pure @property {
            T opDispatch(string v)() const if( getIndex(AS,v,VVASES,VVASVS) != -1 ) { 
                mixin( format( "return this.%s[%d];", data, getIndex(AS,v,VVASES,VVASVS) ) ); 
            }

            ref T opDispatch(string v)() if( getIndex(AS,v,VVASES,VVASVS) != -1 ) { 
                mixin( format( "return this.%s[%d];", data, getIndex(AS,v,VVASES,VVASVS) ) ); 
            }

            static if( isOneSymbolPerFieldForAnyAccessString(AS,VVASES,VVASVS) ) {
                auto opDispatch(string v)() const if( v.length > 1 && oneOfAnyAccessAll(AS,v,VVASES,VVASVS) ) {
                    static string gen() {
                        string[] res;
                        foreach( i, sym; v )
                            res ~= format( "this.%s[%d]", data, getIndex( AS, ""~sym, VVASES, VVASVS ) );
                        return res.join(",");
                    }

                    mixin( `return Vector!(T, v.length)(` ~ gen() ~ `);` );
                }

                auto opDispatch(string v,U)( in U b ) 
                if( v.length > 1 && oneOfAnyAccessAll(AS,v,VVASES,VVASVS) && 
                    isCompatibleArrayAccessString(v.length,v) && 
                ( isSpecVector!(v.length,T,U) || ( isDynamicVector!U && is(typeof(T(U.datatype.init))) ) ) ) {
                    static if( b.isDynamic ) enforce( v.length == b.length );

                    static string gen() {
                        string[] res;
                        foreach( i, sym; v )
                            res ~= format( "this.%s[%d] = T( b[%d] );", data,
                                        getIndex( AS, ""~sym, VVASES, VVASVS ), i );
                        return res.join("\n");
                    }

                    mixin( gen() );
                    return b;
                }
            }
        }
    }

    /// compatible for creating access dispatches
    pure bool isCompatibleArrayAccessStrings( size_t N, string str, string sep1="", string sep2="|" )
    in { assert( sep1 != sep2 ); } do {
        auto strs = str.split(sep2);
        foreach( s; strs )
            if( !isCompatibleArrayAccessString(N,s,sep1) )
                return false;

        string[] fa;
        foreach( s; strs )
            fa ~= s.split(sep1);

        foreach( ref v; fa ) v = strip(v);

        foreach( i, a; fa )
            foreach( j, b; fa )
                if( i != j && a == b ) return false;

        return true;
    }


    /// compatible for creating access dispatches
    pure bool isCompatibleArrayAccessString( size_t N, string str, string sep="" ) { 
        return N == getAccessFieldsCount(str,sep) && isArrayAccessString(str,sep); 
    }

    ///
    pure bool isArrayAccessString( in string as, in string sep="", bool allowDot=false ) {
        if( as.length == 0 ) return false;
        auto splt = as.split(sep);
        foreach( i, val; splt )
            if( !isValueAccessString(val,allowDot) || canFind(splt[0..i],val) )
                return false;
        return true;
    }

    ///
    pure size_t getAccessFieldsCount( string str, string sep ) { return str.split(sep).length; }

    ///
    pure ptrdiff_t getIndex( string as, string arg, string sep1="", string sep2="|" )
    in { assert( sep1 != sep2 ); } do
    {
        foreach( str; as.split(sep2) )
            foreach( i, v; str.split(sep1) )
                if( arg == v ) return i;
        return -1;
    }

    ///
    pure bool oneOfAccess( string str, string arg, string sep="" ) {
        auto splt = str.split(sep);
        return canFind(splt,arg);
    }

    ///
    pure bool oneOfAccessAll( string str, string arg, string sep="" ) {
        auto splt = arg.split("");
        return all!(a=>oneOfAccess(str,a,sep))(splt);
    }

    ///
    pure bool oneOfAnyAccessAll( string str, string arg, string sep1="", string sep2="|" )
    in { assert( sep1 != sep2 ); } do
    {
        foreach( s; str.split(sep2) )
            if( oneOfAccessAll(s,arg,sep1) ) return true;
        return false;
    }

    /// check symbol count for access to field
    pure bool isOneSymbolPerFieldForAnyAccessString( string str, string sep1="", string sep2="|" )
    in { assert( sep1 != sep2 ); } do
    {
        foreach( s; str.split(sep2) )
            if( isOneSymbolPerFieldAccessString(s,sep1) ) return true;
        return false;
    }

    /// check symbol count for access to field
    pure bool isOneSymbolPerFieldAccessString( string str, string sep="" ) {
        foreach( s; str.split(sep) )
            if( s.length > 1 ) return false;
        return true;
    }

    pure
    {

        bool isValueAccessString( in string as, bool allowDot=false ) {
            return as.length > 0 &&
            startsWithAllowedChars(as) &&
            (allowDot?(all!(a=>isValueAccessString(a))(as.split("."))):allowedCharsOnly(as));
        }

        bool startsWithAllowedChars( in string as ) {
            switch(as[0]) {
                case 'a': .. case 'z': goto case;
                case 'A': .. case 'Z': goto case;
                case '_': return true;
                default: return false;
            }
        }

        bool allowedCharsOnly( in string as ) {
            foreach( c; as ) if( !allowedChar(c) ) return false;
            return true;
        }

        bool allowedChar( in char c ) {
            switch(c) {
                case 'a': .. case 'z': goto case;
                case 'A': .. case 'Z': goto case;
                case '0': .. case '9': goto case;
                case '_': return true;
                default: return false;
            }
        }

    }
}