#include <stdio.h>
#include <string.h>
#include <errno.h>
#include "var.h"

struct variable {
    const char *name;
    const unsigned int index;
    const char *data;
};

static int var_lookup(void *context,
    const char *varname, size_t name_len, int index,
    const char **data, size_t *data_len,
    size_t *buffer_size)
{
    const struct variable*  vars = context;
    size_t i, counter, length;
    static char buf[((sizeof(int)*8)/3)+10]; /* sufficient size: <#bits> x log_10(2) + safety */

    if (index >= 0)
        {
        for (i = 0; vars[i].name; ++i)
            {
            if (strncmp(varname, vars[i].name, name_len) == 0 && vars[i].index == index)
                {
                *data = vars[i].data;
                *data_len = strlen(*data);
                *buffer_size = 0;
                return 1;
                }
            }
        }
    else
        {
        for (i = 0; vars[i].name; ++i)
            {
            if (strncmp(varname, vars[i].name, name_len) == 0)
                {
                printf("Found variable at index %d.\n", i);
                counter = 1;
                length = strlen(vars[i].data);
                while (vars[i + counter].data && strncmp(varname, vars[i + counter].name, name_len) == 0)
                    ++counter;
                if (counter == 1)
                    sprintf(buf, "%d", length);
                else
                    sprintf(buf, "%d", counter);
                *data = buf;
                *data_len = strlen(buf);
                *buffer_size = 0;
                return 1;
                }
            }
        }
    return 0;
}

struct test_case {
    const char *input;
    const char *expected;
};

int main(int argc, char **argv)
{
    const struct variable vars[] = {
        { "HOME",   0, "/home/regression-tests" },
        { "OSTYPE", 0, "regression-os" },
        { "TERM",   0, "regression-term" },
        { "FOO",    0, "os" },
        { "BAR",    0, "type" },
        { "EMPTY",  0, "" },
        { "ARRAY",  0, "entry0" },
        { "ARRAY",  1, "entry1" },
        { "ARRAY",  2, "entry2" },
        { "ARRAY",  3, "entry3" },
        { "NUMBER", 0, "+2" },
        { "NUMEXP", 0, "((16)%5)" },
        { NULL,     0, NULL }
        };

    const struct test_case tests[] = {
        { "$HOME",                        "/home/regression-tests"                         },
        { "${FOO}",                       "os"                                             },
        { "${BAR}",                       "type"                                           },
        { "${${FOO:u}${BAR:u}:l:u}",      "REGRESSION-OS"                                  },
        { "${UNDEFINED}",                 "${UNDEFINED}"                                   },
        { "${OSTYPE:#}",                  "13"                                             },
        { "${EMPTY:-test${FOO}test}",     "testostest"                                     },
        { "${EMPTY:-test${FOO:u}test}",   "testOStest"                                     },
        { "${TERM:-test${FOO}test}",      "regression-term"                                },
        { "${EMPTY:+FOO}",                ""                                               },
        { "${HOME:+test${FOO}test}",      "testostest"                                     },
        { "${HOME:+${OS${BAR:u}}}",       "regression-os"                                  },
        { "${HOME:+OS${UNDEFINED:u}}",    "OS${UNDEFINED:u}"                               },
        { "${UNDEFINED:+OS${BAR:u}}",     "${UNDEFINED:+OS${BAR:u}}"                       },
        { "${HOME:*heinz}",               ""                                               },
        { "${EMPTY:*claus}",              "claus"                                          },
        { "${TERM}",                      "regression-term"                                },
        { "${HOME:s/reg/bla/}",           "/home/blaression-tests"                         },
        { "${HOME:s/e/bla/}",             "/hombla/regression-tests"                       },
        { "${HOME:s/e/bla/g}",            "/hombla/rblagrblassion-tblasts"                 },
        { "${HOME:s/\\//_/g}",            "_home_regression-tests"                         },
        { "${HOME:s/[eso]/_/g}",          "/h_m_/r_gr___i_n-t__t_"                         },
        { "${HOME:s/[esO]/_/g}",          "/hom_/r_gr___ion-t__t_"                         },
        { "${HOME:s/[esO]/_/gi}",         "/h_m_/r_gr___i_n-t__t_"                         },
        { "${OSTYPE:s/^[re]/_/g}",        "_egression-os"                                  },
        { "${EMPTY:s/^[re]/_/g}",         ""                                               },
        { "${HOME:s/.*/heinz/}",          "heinz"                                          },
        { "${HOME:s/e/bla/t}",            "/hombla/regression-tests"                       },
        { "${HOME:s/E/bla/t}",            "/home/regression-tests"                         },
        { "${HOME:s/E/bla/ti}",           "/hombla/regression-tests"                       },
        { "${HOME:s/E/bla/tig}",          "/hombla/rblagrblassion-tblasts"                 },
        { "${HOME:o1-5}",                 "home/"                                          },
        { "${HOME:o1,5}",                 "home/"                                          },
        { "${HOME:o5,}",                  "/regression-tests"                              },
        { "${HOME:o5-}",                  "/regression-tests"                              },
        { "${HOME:o7,13}",                "egressi"                                        },
        { "${HOME:y/a-z/A-YZ/}",          "/HOME/REGRESSION-TESTS"                         },
        { "${HOME:y/e-g/a-c/}",           "/homa/racrassion-tasts"                         },
        { "${FOO:p/15/../l}",             "os............."                                },
        { "${FOO:p/15/12345/l}",          "os1234512345123"                                },
        { "${FOO:p/15/../r}",             ".............os"                                },
        { "${FOO:p/15/12345/r}",          "1234512345123os"                                },
        { "${FOO:p/15/../c}",             "......os......."                                },
        { "${FOO:p/15/12345/c}",          "123451os1234512"                                },
        { "${FOO:s/os/\\x{4F}\\123/g}",   "OS"                                             },
        { "${FOO:s/os/\\1\\x4F\\123/t}",  "\\1OS"                                          },
        { "${HOME:s/g(res)s/x\\1x/g}",    "/home/rexresxion-tests"                         },
        { "${HOME:s/(s+)/_\\1_/g}",       "/home/regre_ss_ion-te_s_t_s_"                   },
        { "${HOME:s/\\x65/\\x45/g}",      "/homE/rEgrEssion-tEsts"                         },
        { "${HOME:s/(s*)/x\\1X/g}",       "xXxXxXxXxXxXxXxXxXxXxXxssXxXxXxXxXxXxXxsXxXxsX" },
        { "${HOME:s/./\\\\/g}",           "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"   },
        { "${ARRAY[1]}",                  "entry1",                                        },
        { "${ARRAY[5+4*2-1]}",            "${ARRAY[5+4*2-1]}",                             },
        { "${ARRAY[(5+(3+4)*2)%16]}",     "entry3",                                        },
        { "${ARRAY[(5+(3+4)*2)/9]}",      "entry2",                                        },
        { "${ARRAY[+1--2]}",              "entry3"                                         },
        { "${ARRAY[-1]}",                 "4"                                              },
        { "${HOME[-1]}",                  "22"                                             },
        { "${ARRAY[$NUMBER]}",            "entry2"                                         },
        { "${ARRAY[$NUMEXP]}",            "entry1"                                         },
        { "${ARRAY[$NUMEXP-1]}",          "entry0"                                         },
        { "${ARRAY[${UNDEFINED}-1]}",     "${ARRAY[${UNDEFINED}-1]}"                       },
        { "${ARRAY[5/(${UNDEFINED})]}",   "${ARRAY[5/(${UNDEFINED})]}"                     },
        { "[${ARRAY}-]",                  "entry0-entry1-entry2-entry3-"                   }
    };
    char *tmp;
    size_t tmp_len;
    var_rc_t rc;
    size_t i;
    char buffer[1024];

    for (i = 0; i < sizeof(tests) / sizeof(struct test_case); ++i) {
#ifdef DEBUG
        printf("Test case #%02d: Original input is '%s'.\n", i,
           tests[i].input);
#endif
        rc = var_unescape(tests[i].input, strlen(tests[i].input), buffer, 0);
        if (rc != VAR_OK) {
            printf ("Test case #%d: First var_unescape() failed with return code %d ('%s').\n",
                    i, rc, var_strerror(rc));
            return 1;
        }
#ifdef DEBUG
        printf("Test case #%02d: Unescaped input is '%s'.\n", i, buffer);
#endif
        rc = var_expand(buffer, strlen(buffer), &tmp, &tmp_len,
            &var_lookup, (void *)vars, NULL, 0);
        if (rc != VAR_OK) {
            printf ("Test case #%d: var_expand() failed with return code %d ('%s').\n",
                    i, rc, var_strerror(rc));
            return 1;
        }
#ifdef DEBUG
        printf("Test case #%02d: Expanded output is '%s'.\n", i, tmp);
#endif
        if (tmp_len != strlen(tests[i].expected) || tmp == NULL
        || memcmp(tests[i].expected, tmp, tmp_len) != 0) {
            printf("Test case #%d: Expected result '%s' but got '%s'.\n",
                i, tests[i].expected, tmp);
            return 1;
        }
    free(tmp);
    }

    return 0;
}