#include <pcre.h>

#include "log.h"
#include "regex_table.h"

const char *g_regex_tbl[REGEX_MAX] = {

    "^(([1-9]\\d{0,3})|([1-5]\\d{4})|(6[0-4]\\d{3})|(65[0-4]\\d{2})|(655[0-2]"
    "\\d)|(6553[0-5]))$",

    "^((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?"
    ")(\\/(\\d|[1-2]\\d|3[0-2]))?$|^([\\da-fA-F]{1,4}:){6}((25[0-5]|2[0-4]\\d"
    "|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?)(\\/([1-9]?\\d|(1(["
    "0-1]\\d|2[0-8]))))?$|^::([\\da-fA-F]{1,4}:){0,4}((25[0-5]|2[0-4]\\d|[01]"
    "?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?)(\\/([1-9]?\\d|(1([0-1]"
    "\\d|2[0-8]))))?$|^([\\da-fA-F]{1,4}:):([\\da-fA-F]{1,4}:){0,3}((25[0-5]|"
    "2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?)(\\/([1-9]"
    "?\\d|(1([0-1]\\d|2[0-8]))))?$|^([\\da-fA-F]{1,4}:){2}:([\\da-fA-F]{1,4}:"
    "){0,2}((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?"
    "\\d\\d?)(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))?$|^([\\da-fA-F]{1,4}:){3}:"
    "([\\da-fA-F]{1,4}:){0,1}((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]"
    "|2[0-4]\\d|[01]?\\d\\d?)(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))?$|^([\\da-"
    "fA-F]{1,4}:){4}:((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]"
    "\\d|[01]?\\d\\d?)(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))?$|^([\\da-fA-F]{1"
    ",4}:){7}[\\da-fA-F]{1,4}(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))?$|^:((:["
    "\\da-fA-F]{1,4}){1,6}|:)(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))?$|^[\\da-f"
    "A-F]{1,4}:((:[\\da-fA-F]{1,4}){1,5}|:)(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8])"
    ")))?$|^([\\da-fA-F]{1,4}:){2}((:[\\da-fA-F]{1,4}){1,4}|:)(\\/([1-9]?\\d|"
    "(1([0-1]\\d|2[0-8]))))?$|^([\\da-fA-F]{1,4}:){3}((:[\\da-fA-F]{1,4}){1,3"
    "}|:)(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))?$|^([\\da-fA-F]{1,4}:){4}((:["
    "\\da-fA-F]{1,4}){1,2}|:)(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))?$|^([\\da-"
    "fA-F]{1,4}:){5}:([\\da-fA-F]{1,4})?(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))"
    "?$|^([\\da-fA-F]{1,4}:){6}:(\\/([1-9]?\\d|(1([0-1]\\d|2[0-8]))))?$",

    "^(?:(?!0000)[0-9]{4}\\/(?:(?:0[1-9]|1[0-2])\\/(?:0[1-9]|1[0-9]|2[0-8])|("
    "?:0[13-9]|1[0-2])\\/(?:29|30)|(?:0[13578]|1[02])\\/31)|(?:[0-9]{2}(?:0[48"
    "]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)\\/02\\/29"
    ") (20|21|22|23|[0-1][0-9]):[0-5][0-9]$|^(20|21|22|23|[0-1][0-9]):[0-5][0-"
    "9]$",

    "^(20|21|22|23|[0-1][0-9]):[0-5][0-9]$",
};

int pcre_match(int regId, const char *pStr)
{
    pcre *re;
    pcre_extra *pcreExtra;
    const char *error;
    int ret, erroffset;

    if(regId < 0 || regId > REGEX_MAX || !pStr) {
        LOG_EX(LOG_Error, "Input params error: %d, %p\n", regId, pStr);
        return FALSE;
    }

    re = pcre_compile(g_regex_tbl[regId], 0, &error, &erroffset, NULL);

    if(!re) {
        LOG_EX(LOG_Error, "pcre_compile error at %d: %s, %s\n", erroffset,
               g_regex_tbl[regId], error);
        return FALSE;
    }

    pcreExtra = pcre_study(re, 0, &error);

    if(error != NULL) {
        LOG_EX(LOG_Error, "pcre_study error: %s, %s\n", g_regex_tbl[regId], error);
        pcre_free(re);
        return FALSE;
    }

    ret = pcre_exec(re,
                    pcreExtra,
                    pStr,
                    strlen(pStr),  // length of string
                    0,                      // Start looking at this point
                    0,                      // OPTIONS
                    NULL,
                    0);                    // Length of subStrVec

    if(ret < 0) {
        switch(ret) {
            case PCRE_ERROR_NOMATCH      :
                LOG_EX(LOG_Error, "[%s] String did not match the pattern\n", pStr);
                break;

            case PCRE_ERROR_NULL         :
                LOG_EX(LOG_Error, "[%s] Something was null\n", pStr);
                break;

            case PCRE_ERROR_BADOPTION    :
                LOG_EX(LOG_Error, "[%s] A bad option was passed\n", pStr);
                break;

            case PCRE_ERROR_BADMAGIC     :
                LOG_EX(LOG_Error, "Magic number bad (compiled re corrupt?)\n");
                break;

            case PCRE_ERROR_UNKNOWN_NODE :
                LOG_EX(LOG_Error, "[%s] Something kooky in the compiled re\n", pStr);
                break;

            case PCRE_ERROR_NOMEMORY     :
                LOG_EX(LOG_Error, "[%s] Ran out of memory\n", pStr);
                break;

            default                      :
                LOG_EX(LOG_Error, "[%s] Unknown error\n", pStr);
                break;
        } /* end switch */
    } else {
        ret = TRUE;
    }

    pcre_free(re);

    if(pcreExtra != NULL) {
#ifdef PCRE_CONFIG_JIT
        pcre_free_study(pcreExtra);
#else
        pcre_free(pcreExtra);
#endif
    }

    return ret;
}

#if 0
int regex_match(const char *regex, const char *pStr)
{
    int result = FALSE;
    regex_t reg;
    int regexInit;

    if(!regex || !pStr) {
        LOG_EX(LOG_Error, "Input params error: %p, %p\n", regex, pStr);
        return FALSE;
    }

    regexInit = regcomp(&reg, regex, REG_EXTENDED);

    if(regexInit) {
        LOG_EX(LOG_Error, "regcomp error\n");
        return FALSE;
    } else {
        int reti = regexec(&reg, pStr, 0, NULL, 0);

        if(REG_NOERROR != reti) {
            char buf[1024];
            memset(buf, 0, 1024);
            //Error print: match failed!
            regerror(reti, regexInit, buf, 1024);
            LOG_EX(LOG_Error, "%s match %s failed(%d): %s\n", regex, pStr, reti, buf);
        } else {
            //LOG_EX(LOG_Debug, "%s match %s OK\n", regex, pStr);
            result = TRUE;
        }
    }

    regfree(&reg);
    return result;
}
#endif