#include "trygvis/kicad/netlist.h"

using namespace trygvis::kicad;
using trygvis::kicad::netlist::component;
using trygvis::kicad::netlist::kicad_net_loader;
using trygvis::kicad::netlist::kicad_parse_exception;
using trygvis::kicad::netlist::net;
using nl = trygvis::kicad::netlist::netlist;

#include "pybind11/pybind11.h"
#include "pybind11/stl.h"
#include "pybind11/eval.h"

namespace py = pybind11;

#include <fstream>
#include <sstream>
#include <err.h>
#include <sysexits.h>
#include <map>
#include <cstring>
#include <experimental/filesystem>

using namespace std;
namespace fs = std::experimental::filesystem;

#ifdef _WIN32
static string PATH_SEPARATOR(";");
#else
static string PATH_SEPARATOR(":");
#endif

char *program;

__attribute__((noreturn))
void usage(const char *reason = nullptr) {
    if (reason) {
        fprintf(stderr, "error: %s\n", reason);
    }
    fprintf(stderr, "usage: %s -n <net file> -r <ref> -t <template> [-l <template lib dir>] [-o <out file>]\n",
            program);
    exit(EX_USAGE);
}

struct opts {
    bool debug;
    string net_filename;
    string ref;
    string py_template;
    opt<string> out_filename;
    vector<fs::path> template_libs;
};

struct opts parse_args(int argc, char **argv) {
    struct opts opts = {
            .debug = false,
            .net_filename = "",
            .ref = "",
            .py_template = "",
            .out_filename = nullopt,
            .template_libs = {},
    };

    int c;
    while ((c = getopt(argc, argv, "Dn:r:o:t:l:")) != -1) {
        switch (c) {
            case 'D':
                opts.debug = true;
                break;
            case 'n':
                opts.net_filename = optarg;
                break;
            case 'r':
                opts.ref = optarg;
                break;
            case 't':
                opts.py_template = optarg;
                break;
            case 'l':
                opts.template_libs.push_back(fs::path(optarg));
                break;
            case 'o':
                if (strcmp("-", optarg) != 0) {
                    opts.out_filename = string(optarg);
                }
                break;
            default:
                usage();
        }
    }

    if (opts.net_filename.empty() || opts.ref.empty() || opts.py_template.empty()) {
        usage();
    }

    return opts;
}

static
opt<fs::path> find_py_template(const string &py_template, const vector<fs::path> &paths) {

    fs::path p(py_template + ".py");

    if (fs::exists(p)) {
        return p;
    }

    for (auto &&prefix : paths) {
        p = prefix / (py_template + ".py");

        if (fs::exists(p)) {
            return p;
        }
    }

    return nullopt;
}

bool generate(const string &ref, nl *const netlist, stringstream &out, const fs::path &py_template) {
    py::dict vars;
    py::module::import("kicad_utils_py");
    vars = py::module::import("__main__").
        attr("__dict__");

    pybind11::object netlist_py = py::cast(netlist);

    vars["netlist"] = netlist_py;
    vars["ref"] = py::cast(ref);

    string init;
    init += "import kicad_utils_py\n";
    init += "generateHeader = kicad_utils_py.GenerateHeader(ref, netlist)\n";
    init += "del ref\n";
    init += "del netlist\n";
    py::eval<py::eval_mode::eval_statements>(init, vars);

    py::eval_file(py_template.string(), vars);

    string str = py::eval<py::eval_mode::eval_expr>("generateHeader.str", vars).cast<py::object>().cast<string>();
    out << str;

    return true;
}

__attribute__((unused)) static
void show_env() {
    map<string, string> env;
    for (char **e = environ; *e != NULL; e++) {
        string s = *e;
        auto i = s.find('=');
        env[s.substr(0, i)] = s.substr(i + 1);
    }

    for (auto &&e: env) {
        cout << e.first << " = " << e.second << endl;
    }
}

__attribute__((unused)) static
void show_py_info() {
    cerr << "Compile-time Python version: " << PY_VERSION << endl;
    cerr << "Current python version: " << Py_GetVersion() << endl;
}

class python_init {
private:
    wchar_t *program = nullptr;

public:
    class python_init_error : public std::runtime_error {
    public:
        python_init_error(const string &what) : runtime_error(what) {}
    };

    python_init(bool debug, const char *argv0, const vector<fs::path> &python_paths) {
        std::wstring_convert<codecvt_utf8<wchar_t>> converter;

        wstring pythonpath(Py_GetPath());
        for (auto &path : python_paths) {
            if (!fs::exists(path)) {
                continue;
            }
            pythonpath = converter.from_bytes(path.string() + PATH_SEPARATOR) + pythonpath;
        }

        if (debug) {
            wcerr << "PYTHONPATH: " << pythonpath << endl;
        }
        Py_SetPath(pythonpath.c_str());

        program = Py_DecodeLocale(argv0, NULL);
        if (program == NULL) {
            throw python_init_error("Fatal error: cannot decode argv[0]\n");
        }
        Py_SetProgramName(program);

        if (debug) {
            show_py_info();
        }

        Py_Initialize();
    }

    ~python_init() {
        Py_Finalize();
        PyMem_RawFree(program);
    }
};

int main(int argc, char **argv) {
    program = argv[0];

    fs::path bin(argv[0]);
    fs::path basedir = bin.parent_path().parent_path();

    struct opts opts = parse_args(argc, argv);

    opts.template_libs.push_back(fs::current_path());
    opts.template_libs.push_back(basedir / "share" / "kicad-utils" / "templates");

    kicad_net_loader loader;

    if (opts.debug) {
        show_env();
    }

    try {
        nl netlist = loader.load(opts.net_filename, cerr);

        stringstream out;

        cerr << "Template search path: " << endl;
        for (auto &&p : opts.template_libs) {
            cerr << "  " << p.string() << endl;
        }

        opt<fs::path> py_template = find_py_template(opts.py_template, opts.template_libs);

        if (!py_template) {
            cerr << "No such file: " << opts.py_template << endl;
            cerr << "Search path: " << endl;
            for (auto &&p : opts.template_libs) {
                cerr << "  " << p.string() << endl;
            }
            cerr << "Current path is " << fs::current_path().string() << endl;
            return EXIT_FAILURE;
        }

        vector<fs::path> module_paths{
                basedir / "python",
                basedir / "lib",
        };

        python_init python(opts.debug, argv[0], module_paths);
        try {
            auto ok = generate(opts.ref, &netlist, out, py_template.value());

            if (ok) {
                auto contents = out.str();
                if (opts.out_filename) {
                    ofstream outstream(opts.out_filename.value());
                    outstream << contents;
                    outstream.close();
                } else {
                    cout << contents << flush;
                }
                return EXIT_SUCCESS;
            }
        } catch (py::error_already_set &e) {
            cerr << "Python failure:" << endl << e.what() << endl;
        } catch (std::runtime_error &e) {
            cerr << "Generation failed: " << e.what() << endl;
        }

        return EXIT_SUCCESS;
    } catch (python_init::python_init_error &e) {
        errx(EX_IOERR, e.what());
    } catch (kicad_parse_exception &e) {
        for (auto &m: e.messages) {
            fprintf(stderr, "%s\n", m.c_str());
        }
        errx(EX_DATAERR, "Could not parse netlist");
    }
}