// Written in D programming language
/**
*   Module handles functions and templates that we lazied to factor out to separate module.
*
*   Function categories:
*   <ul>
*   <li> JSON de/serialization based on annotations </li>
*   <li> Exception handling functions </li>
*   <li> Cheat casting functions </li>
*   <li> String processing functions (the only one $(B fromStringz))</li>
*   <li> Introspecting templates that cannot be found in Phobos </li> 
*   <li> Functional styled utilities for optional values and lazy ranges</li> 
*   </ul>
*
*   Copyright: © 2014 DSoftOut
*   License: Subject to the terms of the MIT license, as written in the included LICENSE file.
*   Authors: Zaramzan <shamyan.roman@gmail.com>, 
*            NCrashed <ncrashed@gmail.com>
*/
module util;

import std.algorithm;
import std.exception;
import std.string;
import std.conv;
import std.container;
import std.traits;
import std.typecons;
import std.typetuple;
import std.range;
import std.path;
import vibe.data.json;

enum APPNAME = "pgator";

mixin template t_field(T, alias fieldName)
{
	mixin("private "~T.stringof~" m_"~fieldName~";");
	
	mixin("private bool f_"~fieldName~";");
	
	mixin(T.stringof~" "~fieldName~"() @property { return m_"~fieldName~";}");
	
	mixin("private void "~fieldName~"("~T.stringof~" f) @property { m_"~fieldName~"= f; f_"~fieldName~"=true;}");
}

//For deserializeFromJson
enum required;

//For deserializeFromJson
enum possible;


/**
* Deserializes from Json to type T<br>
*
* Supported only structs yet
*
* Example:
* ----
* struct S
* {
*    @required
*	int a; //get value from Json. Throws RequiredFieldException
*
*    @possible
*	int b; //tries to get value from Json
*
*	int c; //will be ignored
* }
*
* auto s = deserializeFromJson!S(json);
* ------
*
* Authors: Zaramzan <shamyan.roman@gmail.com>
*/
T deserializeFromJson(T)(Json src) if(is(T == struct))
{
	T ret;
		
	if (src.type != Json.Type.object)
	{
		throw new RequiredJsonObject("Required json object");
	}
	
	void processStruct(string mem, bool isMemberOptional, Ret)(out Ret retMem, Json srcMem)
	{
		static if (is(Ret == Json))
		{
			retMem = srcMem;
		}
		else
		{
			if (srcMem.type == Json.Type.object)
			{	
				retMem = deserializeFromJson!Ret(srcMem);
			}
			else
			{
				// issue #96, is struct has default constructor 
				// and marked with @possible and received null
				static if(isMemberOptional && __traits(compiles, Ret() ))
				{
					if(srcMem.type == Json.Type.null_)
					{
						retMem = Ret();
					} else
					{
						throw new RequiredFieldException(text("Field ", mem, " must be object in json: ", src));
					}
				} else
				{
					throw new RequiredFieldException(text("Field ", mem, " must be object in json: ", src)); 
				}
			}
		}
	}
	
	void processArray(string mem, bool isMemberOptional, Ret)(out Ret retMem, Json srcMem)
	{
		if (srcMem.type == Json.Type.array)
		{
			alias ElementType!Ret ElemType;
			
			ElemType[] arr = new ElemType[0];
			
			foreach(json; srcMem)
			{
				static if (is(ElemType == struct))
				{
					arr ~= deserializeFromJson!ElemType(json);
				}
				else
				{
				    static if(__traits(compiles, {ElemType t = null;}))
				    {
				        if(json.type == Json.Type.null_)
				        {
				            arr ~= null;
				            continue;
				        }
				    } 
				    arr ~= json.to!ElemType;
				}
			}
			
			retMem = arr;
		} 
		else
		{
			// array could be a null for @possible. issue #96
			static if(isMemberOptional)
			{
				if(srcMem.type == Json.Type.null_)
				{
					retMem = null;
				} else
				{
					throw new RequiredFieldException(text("Field ", mem, " must be array in json: ", src));
				}
			} else
			{
				throw new RequiredFieldException(text("Field ", mem, " must be array in json: ", src));
			}
		}	
	}
	
	foreach(mem; __traits(allMembers, T))
	{	
		alias getMemberType!(T, mem) MemberType;
		enum isMemberRequired = isRequired!(mem, T);
		enum isMemberOptional = isOptional!(mem, T);
		
		enum srcMem = "src."~mem;
		enum retMem = "ret."~mem;
		
		static if (isMemberRequired || isMemberOptional)
		{
			if (mixin(srcMem).type != Json.Type.undefined)
			{
				static if(is(MemberType == struct))
				{
					processStruct!(mem, isMemberOptional)(mixin(retMem), mixin(srcMem));
				} 
				else static if(isArray!MemberType && !isSomeString!MemberType)
				{
					processArray!(mem, isMemberOptional)(mixin(retMem), mixin(srcMem));
				}
				else
				{
					mixin(retMem) = mixin(srcMem).to!MemberType();
				}
			}
			else static if (isMemberRequired)
			{
				throw new RequiredFieldException(text("Field ", mem, " required in json: ", src));
			}
		}
		
	}
	
	return ret;
}
unittest // issue #96
{
	struct A
	{
		@possible
		ubyte[] a;
	}
	
	auto a = A(null);
	assert(deserializeFromJson!A(serializeToJson(a)) == a);
	
	struct B
	{
		@possible
		A a;
	}
	
	auto b = B(A(null));
	assert(deserializeFromJson!B(serializeToJson(b)) == b);
}

/**
* Serializes struct with $(B @required) attributes fields to Json  <br>
* 
* Example
* ------
* struct S
* {
*    @required
*	int a = 1; //will be used
*
*    @possible
*	int b = 2; //will be ignored
*
*	int c; //will be ignored
* }
*
* writeln(serializeRequiredToJson(S())); // { "a":1 }
* ------
*/
Json serializeRequiredToJson(T)(T val)
{
	static assert (is(T == struct), "Need struct type, not "~T.stringof);
	
	Json ret = Json.emptyObject;
	
	foreach(mem; __traits(allMembers, T))
	{
		static if (isRequired!(mem, T))
		{
			alias getMemberType!(T, mem) MemType;
			
			alias vibe.data.json.serializeToJson vibeSer;
			
			static if (is(MemType == struct))
			{
				ret[mem] = serializeRequiredToJson!MemType(mixin("val."~mem));
			}
			else static if (isArray!MemType)
			{
				alias ElementType!MemType EType;
				static if (is(EType == struct))
				{
					auto j1 = Json.emptyArray;
				
					foreach(elem; mixin("val."~mem))
					{
						j1 ~= serializeRequiredToJson(elem);
					}
					
					ret[mem] = j1;
				}
				else
				{
					ret[mem] = vibeSer(mixin("val."~mem));
				}
			}
			else
			{
				ret[mem] = vibeSer(mixin("val."~mem));
			}
		}
	}
	
	return ret;
}

private bool isRequired(alias mem, T)()
{
  bool flag = false;
	foreach(attr;__traits(getAttributes, mixin("T."~mem)))
	{
		static if (is(attr == required))
		{
			flag = true;
      break;
		}
	}
	
	return flag;
}

private bool isOptional(alias mem, T)()
{
  bool flag = false;
	foreach(attr;__traits(getAttributes, mixin("T."~mem)))
	{
		static if (is(attr == possible))
		{
			flag = true;
      break;
		}
	}
	
	return flag;
}

class RequiredFieldException:Exception
{
	this(in string msg)
	{
		super(msg);
	}
}

class RequiredJsonObject:Exception
{
	this(in string msg)
	{
		super(msg);
	}
}

/**
* Tries to call function. On exception throws Ex, otherwise return func() result
*
* Authors: Zaramzan <shamyan.roman@gmail.com>
*/
template tryEx(Ex, alias func)
{
	static assert(isSomeFunction!func, "func must be some function");
	static assert(is(Ex:Exception), "Ex must be Exception");
	
	auto wrapper(TP...)(TP params)
	{	
		try
		{
			return func(params);
		}
		catch(Exception ex)
		{
			throw new Ex(ex.msg, ex.file, ex.line);
		}
	}

	alias wrapper tryEx;
}

/**
* Tries to evaluate par. On exception throws Ex, otherwise return par
*
* Authors: Zaramzan <shamyan.roman@gmail.com>
*/
T tryEx(Ex, T)(lazy T par)
{
	static assert(is(Ex:Exception), "Ex must be Exception");
	
	try
	{
		return par;
	}
	catch(Exception ex)
	{
		throw new Ex(ex.msg, ex.file, ex.line);
	}
}

/**
* cast to shared type T
*
* Warning:
*	Don't use this, if you want send object to another thread. It just dirty hack.
*/
template toShared(T)
{
	private alias Unqual!T P;
	
	shared(P) toShared(T par)
	{
		return cast(shared P) cast(P) par;
	}
}

/// cast to unqual type T
template toUnqual(T)
{
	private alias Unqual!T P;
	
	P toUnqual(T par)
	{
		return cast(P) par;
	}
}

version(unittest)
{
	bool thrower()
	{
		throw new Exception("Exception");
	}
	
	class TestException: Exception
	{
		@safe pure nothrow this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null)
		{
			super(msg, file, line, next); 
		}
	}
}

unittest
{
	import std.exception;
	
	assertThrown!TestException(tryEx!TestException(thrower()));
}

static if (__VERSION__ < 2066) { // from phobos 2.066-b1
	import std.c.string;
	
	/++
	    Returns a D-style array of $(D char) given a zero-terminated C-style string.
	    The returned array will retain the same type qualifiers as the input.
	
	    $(RED Important Note:) The returned array is a slice of the original buffer.
	    The original data is not changed and not copied.
	+/
	
	inout(char)[] fromStringz(inout(char)* cString) @system pure {
	    return cString ? cString[0 .. strlen(cString)] : null;
	}
	
	///
	@system pure unittest
	{
	    assert(fromStringz(null) == null);
	    assert(fromStringz("foo") == "foo");
	}
} else {
	public import std.string: fromStringz;
}

/// getMemberType
/**
*   Retrieves member type with $(D name) of class $(D Class). If member is agregate 
*   type declaration or simply doesn't exist, retrieves no type. You can check it with
*   $(D is) operator.
*
*   Example:
*   -----------
*   class A 
*   {
*       int aField;
*       string b;
*       bool c;
*       
*       class B {}
*       struct C {}
*       union D {}
*       interface E {}
*   }
*
*   static assert(is(getMemberType!(A, "aField") == int));
*   static assert(is(getMemberType!(A, "b") == string));
*   static assert(is(getMemberType!(A, "c") == bool));
*
*   static assert(!is(getMemberType!(A, "B")));
*   static assert(!is(getMemberType!(A, "C")));
*   static assert(!is(getMemberType!(A, "D")));
*   static assert(!is(getMemberType!(A, "E")));
*   -----------
*/
template getMemberType(Class, string name)
{
    static if(hasMember!(Class, name))
        alias typeof(__traits(getMember, Class, name)) getMemberType;
}

unittest
{
    class A 
    {
        int a;
        string b;
        bool c;

        class B {}
        struct C {}
        union D {}
        interface E {}
    }

    static assert(is(getMemberType!(A, "a") == int));
    static assert(is(getMemberType!(A, "b") == string));
    static assert(is(getMemberType!(A, "c") == bool));

    static assert(!is(getMemberType!(A, "B")));
    static assert(!is(getMemberType!(A, "C")));
    static assert(!is(getMemberType!(A, "D")));
    static assert(!is(getMemberType!(A, "E")));
}

/**
*   Struct-wrapper to handle result of computations,
*   that can fail.
*
*   Example:
*   ---------
*   class A {}
*   
*   auto a = new A();
*   auto ma = Maybe!A(a);
*   auto mb = Maybe!A(null);
*   
*   assert(!ma.isNothing);
*   assert(mb.isNothing);
*   
*   assert(ma.get == a);
*   assertThrown!Error(mb.get);
*   
*   bool ncase = false, jcase = false;
*   ma.map(() {ncase = true;}, (v) {jcase = true;});
*   assert(jcase && !ncase);
*   
*   ncase = jcase = false;
*   mb.map(() {ncase = true;}, (v) {jcase = true;});
*   assert(!jcase && ncase);
*   ---------
*/
struct Maybe(T)
    if(is(T == class) || is(T == interface) 
        || isPointer!T || isArray!T) 
{
    private T value;
    
    /// Alias to stored type
    alias T StoredType;
    
    /**
    *   Constructing Maybe from $(B value).
    *   If pointer is $(B null) methods: $(B isNothing) returns true and 
    *   $(B get) throws Error.
    */
    this(T value) pure
    {
        this.value = value;
    }
    
    /**
    *   Constructing empty Maybe.
    *   If Maybe is created with the method, it is considred empty
    *   and $(B isNothing) returns false.
    */
    static Maybe!T nothing()
    {
        return Maybe!T(null);
    } 
    
    /// Returns true if stored value is null
    bool isNothing() const
    {
        return value is null;
    }
    
    /**
    *   Unwrap value from Maybe.
    *   If stored value is $(B null), Error is thrown.
    */
    T get()
    {
        assert(value !is null, "Stored reference is null!");
        return value;
    }
    
    /**
    *   Unwrap value from Maybe.
    *   If stored value is $(B null), Error is thrown.
    */
    const(T) get() const
    {
        assert(value !is null, "Stored reference is null!");
        return value;
    }
    
    /**
    *   If struct holds $(B null), then $(B nothingCase) result
    *   is returned. If struct holds not $(B null) value, then
    *   $(justCase) result is returned. $(B justCase) is fed
    *   with unwrapped value.
    */
    U map(U)(U delegate() nothingCase, U delegate(T) justCase)
    {
        return isNothing ? nothingCase() : justCase(value);
    }
    
    /**
    *   If struct holds $(B null), then $(B nothingCase) result
    *   is returned. If struct holds not $(B null) value, then
    *   $(justCase) result is returned. $(B justCase) is fed
    *   with unwrapped value.
    */
    U map(U)(U delegate() nothingCase, U delegate(const T) justCase) const
    {
        return isNothing ? nothingCase() : justCase(value);
    }
}

unittest
{
    class A {}
    
    auto a = new A();
    auto ma = Maybe!A(a);
    auto mb = Maybe!A(null);
    
    assert(!ma.isNothing);
    assert(mb.isNothing);
    
    assert(ma.get == a);
    assertThrown!Error(mb.get);
    
    bool ncase = false, jcase = false;
    ma.map(() {ncase = true;}, (v) {jcase = true;});
    assert(jcase && !ncase);
    
    ncase = jcase = false;
    mb.map(() {ncase = true;}, (v) {jcase = true;});
    assert(!jcase && ncase);
}

/**
*   Struct-wrapper to handle result of computations,
*   that can fail.
*
*   Example:
*   ---------
*   struct A {}
*   
*   auto ma = Maybe!A(A());
*   auto mb = Maybe!A.nothing;
*   
*   assert(!ma.isNothing);
*   assert(mb.isNothing);
*   
*   assert(ma.get == A());
*   assertThrown!Error(mb.get);
*   
*   bool ncase = false, jcase = false;
*   ma.map(() {ncase = true;}, (v) {jcase = true;});
*   assert(jcase && !ncase);
*   
*   ncase = jcase = false;
*   mb.map(() {ncase = true;}, (v) {jcase = true;});
*   assert(!jcase && ncase);
*   ---------
*/
struct Maybe(T)
    if(is(T == struct) || isAssociativeArray!T || isBasicType!T) 
{
    private bool empty;
    private T value;
    
    /// Alias to stored type
    alias T StoredType;
    
    /**
    *   Constructing empty Maybe.
    *   If Maybe is created with the method, it is considred empty
    *   and $(B isNothing) returns false.
    */
    static Maybe!T nothing()
    {
        Maybe!T ret;
        ret.empty = true;
        return ret;
    } 
    
    /**
    *   Constructing Maybe from $(B value).
    *   If Maybe is created with the constructor, it is considered non empty
    *   and $(B isNothing) returns false.
    */
    this(T value) pure
    {
        this.value = value;
        empty = false;
    }
    
    /// Returns true if stored value is null
    bool isNothing() const
    {
        return empty;
    }
    
    /**
    *   Unwrap value from Maybe.
    *   If the Maybe is empty, Error is thrown.
    */
    T get()
    {
        assert(!empty, "Stored value is null!");
        return value;
    }
    
    /**
    *   Unwrap value from Maybe.
    *   If the Maybe is empty, Error is thrown.
    */
    const(T) get() const
    {
        assert(!empty, "Stored value is null!");
        return value;
    }
    
    /**
    *   If struct holds $(B null), then $(B nothingCase) result
    *   is returned. If struct holds not $(B null) value, then
    *   $(justCase) result is returned. $(B justCase) is fed
    *   with unwrapped value.
    */
    U map(U)(U delegate() nothingCase, U delegate(T) justCase)
    {
        return isNothing ? nothingCase() : justCase(value);
    }
    
    /**
    *   If struct holds $(B null), then $(B nothingCase) result
    *   is returned. If struct holds not $(B null) value, then
    *   $(justCase) result is returned. $(B justCase) is fed
    *   with unwrapped value.
    */
    U map(U)(U delegate() nothingCase, U delegate(const T) justCase) const
    {
        return isNothing ? nothingCase() : justCase(value);
    }
}

unittest
{
    struct A {}
    
    auto ma = Maybe!A(A());
    auto mb = Maybe!A.nothing;
    
    assert(!ma.isNothing);
    assert(mb.isNothing);
    
    assert(ma.get == A());
    assertThrown!Error(mb.get);
    
    bool ncase = false, jcase = false;
    ma.map(() {ncase = true;}, (v) {jcase = true;});
    assert(jcase && !ncase);
    
    ncase = jcase = false;
    mb.map(() {ncase = true;}, (v) {jcase = true;});
    assert(!jcase && ncase);
}

/**
*   Transforms delegate into lazy range. Generation is stopped, when
*   $(B genfunc) returns $(B Maybe!T.nothing).
*
*   Example:
*   --------
*   assert( (() => Maybe!int(1)).generator.take(10).equal(1.repeat.take(10)) );
*   assert( (() => Maybe!int.nothing).generator.empty);
*   assert( (() 
*           {
*               static size_t i = 0;
*               return i++ < 10 ? Maybe!int(1) : Maybe!int.nothing;
*           }
*           ).generator.equal(1.repeat.take(10)));
*   
*   class A {}
*   auto a = new A();
*   
*   assert( (() => Maybe!A(a)).generator.take(10).equal(a.repeat.take(10)) );
*   assert( (() => Maybe!A.nothing).generator.empty);
*   assert( (() 
*           {
*               static size_t i = 0;
*               return i++ < 10 ? Maybe!A(a) : Maybe!A.nothing;
*           }
*           ).generator.equal(a.repeat.take(10)));
*   --------
*/
auto generator(T)(Maybe!T delegate() genfunc)
{
    struct Sequencer
    {
        private Maybe!T currvalue;
        
        T front()
        {
            assert(!currvalue.isNothing, "Generator range is empty!");
            return currvalue.get;
        }
        
        bool empty()
        {
            return currvalue.isNothing;
        }
        
        void popFront()
        {
            currvalue = genfunc();
        }
    }
    static assert(isInputRange!Sequencer);
    
    auto s = Sequencer();
    s.popFront;
    return s;
}
unittest
{
    assert( (() => Maybe!int(1)).generator.take(10).equal(1.repeat.take(10)) );
    assert( (() => Maybe!int.nothing).generator.empty);
    assert( (() 
            {
                static size_t i = 0;
                return i++ < 10 ? Maybe!int(1) : Maybe!int.nothing;
            }
            ).generator.equal(1.repeat.take(10)));
    
    class A {}
    auto a = new A();
    
    assert( (() => Maybe!A(a)).generator.take(10).equal(a.repeat.take(10)) );
    assert( (() => Maybe!A.nothing).generator.empty);
    assert( (() 
            {
                static size_t i = 0;
                return i++ < 10 ? Maybe!A(a) : Maybe!A.nothing;
            }
            ).generator.equal(a.repeat.take(10)));
}

private template TypesOf(T...)
{
    static if(T.length == 1)
        alias TypesOf = typeof(T[0]);
    else
        alias TypesOf = TypeTuple!(typeof(T[0]), TypesOf!(T[1..$]));
}

/**
*   Allows to fast retreiving results from functions that returns a tuple.
*/
@property void tie(T...)(Tuple!(TypesOf!T) t)
{
    foreach(i, ref var; T)
    {
        T[i] = t[i];
    }
}
/// Example
unittest
{
    Tuple!(int, string) foo()
    {
        return tuple(1, "a");
    }
    
    int x;
    string y;
    
    tie!(x,y) = foo();
    assert(x == 1 && y == "a");
}