#!/usr/bin/env python
import sys
import gmpapi
from gmpapi import void
from gmpapi import ilong
from gmpapi import iint
from gmpapi import ulong
from gmpapi import mpz_t
from gmpapi import size_t
from gmpapi import charp
from gmpapi import mpq_t


class APITest(object):
    def __init__(self, gmpapi):
        self.api = gmpapi

    def test_prefix(self):
        return "test"

    def test_param_name(self, ty, i):
        if ty == mpz_t:
            pname = "p_zs"
        elif ty == ilong:
            pname = "p_si"
        elif ty == ulong:
            pname = "p_ui"
        elif ty == iint:
            pname = "p_i"
        elif ty == charp:
            pname = "p_cs"
        elif ty == mpq_t:
            pname = "p_qs"
        else:
            raise RuntimeError("Unknown param type: " + str(ty))
        return pname + str(i)

    def test_param_type(self, ty):
        if ty == mpz_t or ty == mpq_t:
            pty_name = "char *"
        else:
            pty_name = str(ty)
        return pty_name

    def test_var_name(self, ty, i):
        if ty == mpz_t:
            vname = "v_z"
        elif ty == ilong:
            vname = "v_si"
        elif ty == ulong:
            vname = "v_ui"
        elif ty == iint:
            vname = "v_i"
        elif ty == size_t:
            vname = "v_st"
        elif ty == charp:
            vname = "v_cs"
        elif ty == mpq_t:
            vname = "v_q"
        else:
            raise RuntimeError("Unknown param type: " + str(ty))
        return vname + str(i)

    def test_var_type(self, ty):
        if ty == mpz_t:
            return self.mpz_type()
        elif ty == mpq_t:
            return self.mpq_type()
        else:
            return str(ty)

    def init_var_from_param(self, ty, var, param):
        code = "\t"
        if ty == mpz_t or ty == mpq_t:
            code += self.api_call_prefix(ty) + "init(" + var + ");\n\t"
            code += self.api_call_prefix(ty) + "set_str(" + ",".join(
                [var, param, "10"]) + ")"
            if ty == mpq_t:
                code += ";\n\t"
                code += self.api_call_prefix(ty) + "canonicalize(" + var + ")"
        else:
            code += var + "=" + param
        return code

    def init_vars_from_params(self):
        code = ""
        for (i, p) in enumerate(self.api.params):
            param = self.test_param_name(p, i)
            code += "\t"
            code += self.test_var_type(p) + " "
            var = self.test_var_name(p, i)
            code += var + ";\n"
            code += self.init_var_from_param(p, var, param) + ";\n\n"
        return code

    def make_api_call(self):
        bare_name = self.api.name.replace("mpz_", "", 1).replace("mpq_", "", 1)
        call_params = [
            self.test_var_name(p, i) for (i, p) in enumerate(self.api.params)
        ]
        ret = "\t"
        ret_ty = self.api.ret_ty
        if ret_ty != void:
            ret += self.test_var_type(ret_ty) + " " + self.test_var_name(
                ret_ty, "_ret") + " = "
        # call mpq or mpz function
        if self.api.name.startswith("mpz_"):
            prefix = self.api_call_prefix(mpz_t)
        else:
            prefix = self.api_call_prefix(mpq_t)
        return ret + prefix + bare_name + "(" + ",".join(call_params) + ");\n"

    def normalize_cmp(self, ty):
        cmpval = self.test_var_name(ty, "_ret")
        code = ""
        code += """
	if ({var} > 0)
	  {var} = 1;
	else if ({var} < 0)
	  {var} = -1;\n\t
""".format(var=cmpval)
        return code

    def extract_result(self, ty, pos):
        code = ""
        if ty == mpz_t or ty == mpq_t:
            var = self.test_var_name(ty, pos)
            code += self.api_call_prefix(
                ty) + "get_str(out+offset, 10," + var + ");\n"
            code += "\toffset = offset + strlen(out); "
            code += "out[offset] = ' '; out[offset+1] = 0; offset += 1;"
        else:
            assert pos == -1, "expected a return value, not a param value"
            if ty == ilong:
                var = self.test_var_name(ty, "_ret")
                code += 'offset = sprintf(out+offset, " %ld ", ' + var + ');'
            elif ty == ulong:
                var = self.test_var_name(ty, "_ret")
                code += 'offset = sprintf(out+offset, " %lu ", ' + var + ');'
            elif ty == iint:
                var = self.test_var_name(ty, "_ret")
                code += 'offset = sprintf(out+offset, " %d ", ' + var + ');'
            elif ty == size_t:
                var = self.test_var_name(ty, "_ret")
                code += 'offset = sprintf(out+offset, " %zu ", ' + var + ');'
            elif ty == charp:
                var = self.test_var_name(ty, "_ret")
                code += 'offset = sprintf(out+offset, " %s ", ' + var + ');'
            else:
                raise RuntimeError("Unknown param type: " + str(ty))
        return code

    def extract_results(self):
        ret_ty = self.api.ret_ty
        code = "\tint offset = 0;\n\t"

        # normalize cmp return values
        if ret_ty == iint and "cmp" in self.api.name:
            code += self.normalize_cmp(ret_ty)

        # call canonicalize for mpq_set_ui
        if self.api.name == "mpq_set_ui":
            code += self.api_call_prefix(
                mpq_t) + "canonicalize(" + self.test_var_name(mpq_t,
                                                              0) + ");\n\t"

        # get return value
        if ret_ty != void:
            code += self.extract_result(ret_ty, -1) + "\n"

        # get out param values
        for pos in self.api.out_params:
            code += "\t"
            code += self.extract_result(self.api.params[pos], pos) + "\n"

        return code + "\n"

    def clear_local_vars(self):
        code = ""
        for (i, p) in enumerate(self.api.params):
            if p == mpz_t or p == mpq_t:
                var = self.test_var_name(p, i)
                code += "\t" + self.api_call_prefix(
                    p) + "clear(" + var + ");\n"
        return code

    def print_test_code(self, outf):
        api = self.api
        params = [
            self.test_param_type(p) + " " + self.test_param_name(p, i)
            for (i, p) in enumerate(api.params)
        ]
        code = "void {}_{}(char *out, {})".format(self.test_prefix(), api.name,
                                                  ", ".join(params))
        code += "{\n"
        code += self.init_vars_from_params()
        code += self.make_api_call()
        code += self.extract_results()
        code += self.clear_local_vars()
        code += "}\n"
        outf.write(code)
        outf.write("\n")


class GMPTest(APITest):
    def __init__(self, gmpapi):
        super(GMPTest, self).__init__(gmpapi)

    def api_call_prefix(self, kind):
        if kind == mpz_t:
            return "mpz_"
        elif kind == mpq_t:
            return "mpq_"
        else:
            raise RuntimeError("Unknown call kind: " + str(kind))

    def mpz_type(self):
        return "mpz_t"

    def mpq_type(self):
        return "mpq_t"


class ImathTest(APITest):
    def __init__(self, gmpapi):
        super(ImathTest, self).__init__(gmpapi)

    def api_call_prefix(self, kind):
        if kind == mpz_t:
            return "impz_"
        elif kind == mpq_t:
            return "impq_"
        else:
            raise RuntimeError("Unknown call kind: " + str(kind))

    def mpz_type(self):
        return "impz_t"

    def mpq_type(self):
        return "impq_t"


def print_gmp_header(outf):
    code = ""
    code += "#include <gmp.h>\n"
    code += "#include <stdio.h>\n"
    code += "#include <string.h>\n"
    code += '#include "gmp_custom_test.c"\n'
    outf.write(code)


def print_imath_header(outf):
    code = ""
    code += "#include <gmp_compat.h>\n"
    code += "#include <stdio.h>\n"
    code += "#include <string.h>\n"
    code += "typedef mpz_t impz_t[1];\n"
    code += "typedef mpq_t impq_t[1];\n"
    code += '#include "imath_custom_test.c"\n'
    outf.write(code)


def print_gmp_tests(outf):
    print_gmp_header(outf)
    for api in gmpapi.apis:
        if not api.custom_test:
            GMPTest(api).print_test_code(outf)


def print_imath_tests(outf):
    print_imath_header(outf)
    for api in gmpapi.apis:
        if not api.custom_test:
            ImathTest(api).print_test_code(outf)


def main():
    test = sys.argv[1]

    if test == "gmp":
        print_gmp_tests(sys.stdout)
    elif test == "imath":
        print_imath_tests(sys.stdout)


if __name__ == "__main__":
    main()
