#ifndef BZS_DB_PROTOCOL_TDAP_FIELD_COMP_H
#define BZS_DB_PROTOCOL_TDAP_FIELD_COMP_H
/*=================================================================
   Copyright (C) 2014 BizStation Corp All rights reserved.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.
=================================================================*/
#include <bzs/db/protocol/tdap/tdapcapi.h>
#include <bzs/env/crosscompile.h>
#include <algorithm>
#include <string.h>


inline __int64 changeEndian2(__int64 v)
{
    __int64 ret = 0;
    char* l = (char*)&ret;
    char* r = (char*)&v;
    l[0] = r[1];
    l[1] = r[0];
    return ret;
}

inline __int64 changeEndian3(__int64 v)
{
    __int64 ret = 0;
    char* l = (char*)&ret;
    char* r = (char*)&v;
    l[0] = r[2];
    l[1] = r[1];
    l[2] = r[0];
    return ret;
}

inline __int64 changeEndian4(__int64 v)
{
    __int64 ret = 0;
    char* l = (char*)&ret;
    char* r = (char*)&v;
    l[0] = r[3];
    l[1] = r[2];
    l[2] = r[1];
    l[3] = r[0];
    return ret;
}

inline __int64 changeEndian5(__int64 v)
{
    __int64 ret = 0;
    char* l = (char*)&ret;
    char* r = (char*)&v;
    l[0] = r[4];
    l[1] = r[3];
    l[2] = r[2];
    l[3] = r[1];
    l[4] = r[0];
    return ret;
}

inline __int64 changeEndian6(__int64 v)
{
    __int64 ret = 0;
    char* l = (char*)&ret;
    char* r = (char*)&v;
    l[0] = r[5];
    l[1] = r[4];
    l[2] = r[3];
    l[3] = r[2];
    l[4] = r[1];
    l[5] = r[0];
    return ret;
}

inline __int64 changeEndian7(__int64 v)
{
    __int64 ret = 0;
    char* l = (char*)&ret;
    char* r = (char*)&v;
    l[0] = r[6];
    l[1] = r[5];
    l[2] = r[4];
    l[3] = r[3];
    l[4] = r[2];
    l[5] = r[1];
    l[6] = r[0];
    return ret;
}

inline __int64 changeEndian8(__int64 v)
{
    __int64 ret = 0;
    char* l = (char*)&ret;
    char* r = (char*)&v;
    l[0] = r[7];
    l[1] = r[6];
    l[2] = r[5];
    l[3] = r[4];
    l[4] = r[3];
    l[5] = r[2];
    l[6] = r[1];
    l[7] = r[0];
    return ret;
}

inline __int64 changeEndian(__int64 v, int len)
{
    switch(len)
    {
    case 1: return v;
    case 2: return changeEndian2(v);
    case 3: return changeEndian3(v);
    case 4: return changeEndian4(v);
    case 5: return changeEndian5(v);
    case 6: return changeEndian6(v);
    case 7: return changeEndian7(v);
    case 8: return changeEndian8(v);
    }
    return v;
}

inline int int24toInt(const char* p)
{
    return ((*((int*)p) & 0xFFFFFF) << 8) / 0x100;
}

inline unsigned int int24toUint(const char* p)
{
    return *((unsigned int*)p) & 0xFFFFFF;
}

inline __int64 myBittoInt64(const char* p, int len)
{
    __int64 v = 0;
    memcpy(&v, p, len);
    return changeEndian8(v);
}

inline void storeInt24(int v, char* p)
{
    memcpy(p, &v, 3);
}

inline void storeUint24(unsigned int v, char* p)
{
    memcpy(p, &v, 3);
}

inline int compareUint24(const char* l, const char* r)
{
    unsigned int lv = int24toUint(l);
    unsigned int rv = int24toUint(r);;
    if (lv < rv)
        return -1;
    if (lv > rv)
        return 1;
    return 0;
}

inline int compareInt24(const char* l, const char* r)
{
    int lv = int24toInt(l);
    int rv = int24toInt(r);

    if (lv < rv)
        return -1;
    else if (lv > rv)
        return 1;
    return 0;
}

template <class T> inline int compare(const char* l, const char* r)
{
    if (*((T*)l) < *((T*)r))
        return -1;
    else if (*((T*)l) > *((T*)r))
        return 1;
    return 0;
}

template <class T> inline int bitMask(const char* l, const char* r)
{
    T v = *((T*)l) & *((T*)r);
    v = (*((T*)r) - v);
    /* 
       When T is __int64 then v is incoreect value. 
       Because return size is int.    
    */
    return  (v > 0) ? 1 : ((v < 0) ? -1 : 0); 
}

template <class T> inline int compare(T l, T r)
{
    if (l < r)
        return -1;
    else if (l > r)
        return 1;
    return 0;
}

template <class T>
inline int compareVartype(const char* l, const char* r, bool bin, bool all, bool incase)
{
    int llen = (*(T*)l);
    int rlen = (*(T*)r);
    int tmp = std::min<int>(llen, rlen);
    if (incase)
        tmp = _strnicmp(l + sizeof(T), r + sizeof(T), tmp);
    else if (bin)
        tmp = memcmp(l + sizeof(T), r + sizeof(T), tmp);
    else
        tmp = strncmp(l + sizeof(T), r + sizeof(T), tmp);

    if (all)
        return (tmp == 0) ? compare<int>(llen, rlen) : tmp; // match complete
    return (tmp == 0 && (llen < rlen)) ? -1 : tmp; // match a part
}

template <class T>
inline int compareWvartype(const char* l, const char* r, bool bin, bool all, bool incase)
{
    int llen = (*(T*)l) / sizeof(char16_t);
    int rlen = (*(T*)r) / sizeof(char16_t);
    int tmp = std::min<int>(llen, rlen);
    if (incase)
        tmp = wcsnicmp16((char16_t*)(l + sizeof(T)), (char16_t*)(r + sizeof(T)),
                         tmp);
    else if (bin)
        tmp =
            wmemcmp16((char16_t*)(l + sizeof(T)), (char16_t*)(r + sizeof(T)), tmp);
    else
        tmp = wcsncmp16((char16_t*)(l + sizeof(T)), (char16_t*)(r + sizeof(T)),
                        tmp);
    if (all)
        return (tmp == 0) ? compare<int>(llen, rlen) : tmp; // match complete
    return (tmp == 0 && (llen < rlen)) ? -1 : tmp; // match a part
}

inline int compareBlobType(const char* l, const char* r, bool bin, bool all, bool incase,
                           int sizeByte)
{
    int llen = 0;
    int rlen = 0;
    memcpy(&llen, l, sizeByte);
    memcpy(&rlen, r, sizeByte);
    int tmp = std::min<int>(llen, rlen);
    const char* lptr = *((const char**)(l + sizeByte));
    const char* rptr = r + sizeByte;
    if (incase)
        tmp = _strnicmp(lptr, rptr, tmp);
    else if (bin)
        tmp = memcmp(lptr, rptr, tmp);
    else
        tmp = strncmp(lptr, rptr, tmp);

    if (all)
        return (tmp == 0) ? compare<int>(llen, rlen) : tmp;
    return (tmp == 0 && (llen < rlen)) ? -1 : tmp;
}

/* int nullComp(bool lnull, bool rnull, char log)
    
    lnull rnull log        ret 
    -----------------------------------------------
    true  true  isNull      0
    true  true  isNotNull   -1
    true  false 0           -1
    false true  isNull      1
    false true  isNotNull   0
    false false 0           2
    -----------------------------------------------

    real value example

    lval  rval        ret
    -----------------------------------------------
    NULL  isNull      0
    NULL  isNotNull  -1
    NULL  2          -1
    1     isNull      1
    1     isNotNull   0
    1     2           2
    -----------------------------------------------
*/ 
inline int nullComp(bool lnull, bool rnull, char log)
{
    if (lnull)
        return (log == eIsNull) ? 0 : -1;
    else if (rnull)
        return (log == eIsNull) ? 1 : 0;
    return 2;
}

template <class T>
inline int compBitAnd(const char* l, const char* r, int len)
{
    return bitMask<T>(l, r);
}

inline int compBitAnd24(const char* l, const char* r, int len)
{
    int lv = int24toInt(l);
    int rv = int24toInt(r);
    return bitMask<int>((const char*)&lv, (const char*)&rv);
}

inline int compBitAnd64(const char* l, const char* r, int len) 
{
    __int64 lv = 0;
    __int64 rv = 0;
    memcpy(&lv, l, len);
    memcpy(&rv, r, len);
    return bitMask<__int64>((const char*)&lv, (const char*)&rv);
}

template <class T>
inline int compNumber(const char* l, const char* r, int len)
{
    return compare<T>(l, r);
}

inline int compNumber24(const char* l, const char* r, int len)
{
    return compareInt24(l, r);
}

inline int compNumberU24(const char* l, const char* r, int len)
{
    return compareUint24(l, r);
}

inline int compMem(const char* l, const char* r, int len)
{
    return memcmp(l, r, len);
}

inline int compString(const char* l, const char* r, int len) 
{
    return strncmp(l, r, len);
}

inline int compiString(const char* l, const char* r, int len) 
{
    return _strnicmp(l, r, len);
}

inline int compWString(const char* l, const char* r, int len) 
{
    return wcsncmp16((char16_t*)l, (char16_t*)r, len/2);
}

inline int compiWString(const char* l, const char* r, int len)
{
    return wcsnicmp16((char16_t*)l, (char16_t*)r, len/2);
}

#define T_BIN true
#define T_STR false

#define T_INCASE true
#define T_CASE false

#define T_CMP_ALL true
#define T_CMP_PART false


template <class T, bool all>
inline int compVarString(const char* l, const char* r, int len)
{
    return compareVartype<T>(l, r, T_STR, all, T_CASE);
}

template <class T, bool all>
inline int compVarString_bin(const char* l, const char* r, int len)
{
    return compareVartype<T>(l, r, T_BIN, all, T_CASE);
}
template <class T, bool all>
inline int compVarString_i(const char* l, const char* r, int len)
{
    return compareVartype<T>(l, r, T_STR, all, T_INCASE);
}

template <class T, bool all>
inline int compVarString_bin_i(const char* l, const char* r, int len)
{
    return compareVartype<T>(l, r, T_BIN, all, T_INCASE);
}

template <class T, bool all>
inline int compWVarString(const char* l, const char* r, int len)
{
    return compareWvartype<T>(l, r, T_STR, all, T_CASE);
}

template <class T, bool all>
inline int compWVarString_bin(const char* l, const char* r, int len) 
{
    return compareWvartype<T>(l, r, T_BIN, all, T_CASE);
}

template <class T, bool all>
inline int compWVarString_i(const char* l, const char* r, int len)
{
    return compareWvartype<T>(l, r, T_STR, all, T_INCASE);
}

template <class T, bool all>
inline int compWVarString_bin_i(const char* l, const char* r, int len) 
{
    return compareWvartype<T>(l, r, T_BIN, all, T_INCASE);
}

template <int sizeByte, bool all>
inline int compBlob(const char* l, const char* r, int len)
{
    return compareBlobType(l, r, T_STR, all, T_CASE, sizeByte);
}

template <int sizeByte, bool all>
inline int compBlob_bin(const char* l, const char* r, int len)
{
    return compareBlobType(l, r, T_BIN, all, T_CASE, sizeByte);
}

template <int sizeByte, bool all>
inline int compBlob_i(const char* l, const char* r, int len)
{
    return compareBlobType(l, r, T_STR, all, T_INCASE, sizeByte);
}

template <int sizeByte, bool all>
inline int compBlob_bin_i(const char* l, const char* r, int len)
{
    return compareBlobType(l, r, T_BIN, all, T_INCASE, sizeByte);
}


typedef int (*comp1Func)(const char* l, const char* r,int len);

typedef bool (*judgeFunc)(int);

inline comp1Func getCompFunc(uchar_td type, ushort_td len, char logType, int sizeByte)
{
    bool compAll = (logType & CMPLOGICAL_VAR_COMP_ALL) != 0;
    bool incase = (logType & CMPLOGICAL_CASEINSENSITIVE) != 0;
    switch (type)
    {
    case ft_integer:
    case ft_autoinc:
    case ft_currency:
    {
        if (logType & (char)eBitAnd)
        {
            switch (len)
            {
            case 1:
                return &compBitAnd<char>;
            case 2:
                return &compBitAnd<short>;
            case 3:
                return &compBitAnd24;
            case 4:
                return &compBitAnd<int>;
            case 8:
                return &compBitAnd<__int64>;
            }
        }else
        {
            switch (len)
            {
            case 1:
                return &compNumber<char>;
            case 2:
                return &compNumber<short>;
            case 3:
                return &compNumber24;
            case 4:
                return &compNumber<int>;
            case 8:
                return &compNumber<__int64>;
            }
        }
    }
    case ft_mychar:
    case ft_string:
        if (incase)
            return &compiString;
        return &compMem;
    case ft_zstring:
    case ft_note:
        if (incase)
            return &compiString;
        return &compString;
    case ft_logical:
    case ft_uinteger:
    case ft_autoIncUnsigned:
    case ft_date:
    case ft_time:
    case ft_timestamp:
    case ft_myyear:
    case ft_mydate:
    case ft_mytime_num_cmp:
    case ft_mydatetime_num_cmp:
    case ft_mytimestamp_num_cmp:
    case ft_set:
    case ft_enum:
    {
        if (logType & (char)eBitAnd)
        {
            switch (len)
            {
            case 1:
                return &compBitAnd<char>;
            case 2:
                return &compBitAnd<short>;
            case 3:
                return &compBitAnd24;
            case 4:
                return &compBitAnd<int>;
            case 8:
                return &compBitAnd<__int64>;
            }
        }else
        {
            switch (len)
            {
            case 1:
                return &compNumber<unsigned char>;
            case 2:
                return &compNumber<unsigned short>;
            case 3:
                return &compNumberU24;
            case 4:
                return &compNumber<unsigned int>;
            case 8:
                return &compNumber<unsigned __int64>;
            }
        }
    }
    case ft_bit:
        if (logType & (char)eBitAnd)
            return &compBitAnd64;
        return &compMem;
    case ft_mytime:
    case ft_mydatetime:
    case ft_mytimestamp:
    case ft_mydecimal:
        return &compMem;
    case ft_float:
        switch (len)
        {
        case 4:
            return &compNumber<float>;
        case 8:
            return &compNumber<double>;
        }
    case ft_mywchar:
    case ft_wstring:
    case ft_wzstring:
        if (incase)
            return &compiWString;
        if ((type == ft_wstring) || (type == ft_mywchar))
            return &compMem;
        return &compWString;
    case ft_lstring:
    case ft_myvarchar:
        if (sizeByte == 1)
        {
            if (incase)
            {
                if (compAll)
                    return &compVarString_i<unsigned char, T_CMP_ALL>;
                return &compVarString_i<unsigned char, T_CMP_PART>;
            }else
            {
                if (compAll)
                    return &compVarString<unsigned char, T_CMP_ALL>;
                return &compVarString<unsigned char, T_CMP_PART>;
            }
        }
        if (incase)
        {
            if (compAll)
                return &compVarString_i<unsigned short, T_CMP_ALL>;
            return &compVarString_i<unsigned short, T_CMP_PART>;
        }
        if (compAll)
            return &compVarString<unsigned short, T_CMP_ALL>;
        return &compVarString<unsigned short, T_CMP_PART>;
    case ft_myvarbinary:
        if (sizeByte == 1)
        {
            if (incase)
            {
                if (compAll)
                    return &compVarString_bin_i<unsigned char, T_CMP_ALL>;
                return &compVarString_bin_i<unsigned char, T_CMP_PART>;
            }
            if (compAll)
                return &compVarString_bin<unsigned char, T_CMP_ALL>;
            return &compVarString_bin<unsigned char, T_CMP_PART>;
        }
        if (incase)
        {
            if (compAll)
                return &compVarString_bin_i<unsigned short, T_CMP_ALL>;
            return &compVarString_bin_i<unsigned short, T_CMP_PART>;
        }
        if (compAll)
            return &compVarString_bin<unsigned short, T_CMP_ALL>;
        return &compVarString_bin<unsigned short, T_CMP_PART>;
    case ft_mywvarchar:
        if (sizeByte == 1)
        {
            if (incase)
            {
                if (compAll)
                    return &compWVarString_i<unsigned char, T_CMP_ALL>;
                return &compWVarString_i<unsigned char, T_CMP_PART>;
            }
            if (compAll)
                return &compWVarString<unsigned char, T_CMP_ALL>;
            return &compWVarString<unsigned char, T_CMP_PART>;
        }
        if (incase)
        {
            if (compAll)
                return &compWVarString_i<unsigned short, T_CMP_ALL>;
            return &compWVarString_i<unsigned short, T_CMP_PART>;
        }
        if (compAll)
            return &compWVarString<unsigned short, T_CMP_ALL>;
        return &compWVarString<unsigned short, T_CMP_PART>;
    case ft_mywvarbinary:
        if (sizeByte == 1)
        {
            if (incase)
            {
                if (compAll)
                    return &compWVarString_bin_i<unsigned char, T_CMP_ALL>;
                return &compWVarString_bin_i<unsigned char, T_CMP_PART>;
            }
            if (compAll)
                return &compWVarString_bin<unsigned char, T_CMP_ALL>;
            return &compWVarString_bin<unsigned char, T_CMP_PART>;
        }
        if (incase)
        {
            if (compAll)
                return &compWVarString_bin_i<unsigned short, T_CMP_ALL>;
            return &compWVarString_bin_i<unsigned short, T_CMP_PART>;
        }
        if (compAll)
            return &compWVarString_bin<unsigned short, T_CMP_ALL>;
        return &compWVarString_bin<unsigned short, T_CMP_PART>;
    case ft_mytext:
    {
        if (compAll)
        {
            if (incase)
            {
                switch(sizeByte)
                {
                case 1:return &compBlob_i<1, T_CMP_ALL>;
                case 2:return &compBlob_i<2, T_CMP_ALL>;
                case 3:return &compBlob_i<3, T_CMP_ALL>;
                case 4:return &compBlob_i<4, T_CMP_ALL>;
                }
            }
            switch(sizeByte)
            {
            case 1:return &compBlob<1, T_CMP_ALL>;
            case 2:return &compBlob<2, T_CMP_ALL>;
            case 3:return &compBlob<3, T_CMP_ALL>;
            case 4:return &compBlob<4, T_CMP_ALL>;
            }
        }
        if (incase)
        {
            switch(sizeByte)
            {
            case 1:return &compBlob_i<1, T_CMP_PART>;
            case 2:return &compBlob_i<2, T_CMP_PART>;
            case 3:return &compBlob_i<3, T_CMP_PART>;
            case 4:return &compBlob_i<4, T_CMP_PART>;
            }
        }
        switch(sizeByte)
        {
        case 1:return &compBlob<1, T_CMP_PART>;
        case 2:return &compBlob<2, T_CMP_PART>;
        case 3:return &compBlob<3, T_CMP_PART>;
        case 4:return &compBlob<4, T_CMP_PART>;
        }
    }
    case ft_myblob:
    case ft_myjson:      //TODO Json binary comp
    case ft_mygeometry:  //TODO geometory binary comp
    {
        if (compAll)
        {
            if (incase)
            {
                switch(sizeByte)
                {
                case 1:return &compBlob_bin_i<1, T_CMP_ALL>;
                case 2:return &compBlob_bin_i<2, T_CMP_ALL>;
                case 3:return &compBlob_bin_i<3, T_CMP_ALL>;
                case 4:return &compBlob_bin_i<4, T_CMP_ALL>;
                }
            }
            switch(sizeByte)
            {
            case 1:return &compBlob_bin<1, T_CMP_ALL>;
            case 2:return &compBlob_bin<2, T_CMP_ALL>;
            case 3:return &compBlob_bin<3, T_CMP_ALL>;
            case 4:return &compBlob_bin<4, T_CMP_ALL>;
            }
        }
        if (incase)
        {
            switch(sizeByte)
            {
            case 1:return &compBlob_bin_i<1, T_CMP_PART>;
            case 2:return &compBlob_bin_i<2, T_CMP_PART>;
            case 3:return &compBlob_bin_i<3, T_CMP_PART>;
            case 4:return &compBlob_bin_i<4, T_CMP_PART>;
            }
        }
        switch(sizeByte)
        {
        case 1:return &compBlob_bin<1, T_CMP_PART>;
        case 2:return &compBlob_bin<2, T_CMP_PART>;
        case 3:return &compBlob_bin<3, T_CMP_PART>;
        case 4:return &compBlob_bin<4, T_CMP_PART>;
        }
        assert(0);
    }
    }
    return NULL;
}

inline bool isMatch1(int v) // eEqual eBitAnd
{
    return (v == 0);
}

inline bool isMatch2(int v) // eGreater
{
    return (v > 0);
}

inline bool isMatch3(int v) // eLess
{
    return (v < 0);
}

inline bool isMatch4(int v) // eNotEq eNotBitAnd
{
    return (v != 0);
}

inline bool isMatch5(int v) // eGreaterEq
{
    return (v >= 0);
}

inline bool isMatch6(int v) // eLessEq
{
    return (v <= 0);
}

inline judgeFunc getJudgeFunc(eCompType log)
{
    switch (log & 0xF)
    {
    case eEqual:
    case eBitAnd: 
        return isMatch1;
    case eGreater: 
        return isMatch2;
    case eLess: 
        return isMatch3;
    case eNotEq: 
        return isMatch4;
    case eNotBitAnd:
    case eGreaterEq:
        return isMatch5;
    case eLessEq: 
        return isMatch6;
    case eIsNull:
    case eIsNotNull:
        return NULL;
    }
    assert(0);
    return NULL;
}

inline bool isEndComp(uchar_td opr, bool ret)
{
    return (opr == eCend) || (!ret && (opr == eCand)) || (ret && (opr == eCor));
}

#endif