// Copyright(c) 2017-2018, Intel Corporation

//

// Redistribution  and  use  in source  and  binary  forms,  with  or  without

// modification, are permitted provided that the following conditions are met:

//

// * Redistributions of  source code  must retain the  above copyright notice,

//   this list of conditions and the following disclaimer.

// * Redistributions in binary form must reproduce the above copyright notice,

//   this list of conditions and the following disclaimer in the documentation

//   and/or other materials provided with the distribution.

// * Neither the name  of Intel Corporation  nor the names of its contributors

//   may be used to  endorse or promote  products derived  from this  software

//   without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE

// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE

// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR

// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF

// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS

// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN

// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)

// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

#include <Python.h>

#include <pybind11/embed.h>

#include <pybind11/pybind11.h>

#include <pybind11/stl.h>

#include <fstream>

#include <iostream>

#include "mock/test_system.h"

#include "platform/fpga_hw.h"

namespace py = pybind11;

using namespace opae::testing;

PYBIND11_EMBEDDED_MODULE(mopae, m) {

  m.doc() = "Open Programmable Acceleration Engine";

}

PYBIND11_EMBEDDED_MODULE(mockopae, m) {

  py::class_<test_platform> pytp(m, "test_platform");

  pytp.def_static("platforms", &test_platform::platforms)

      .def_static("get", &test_platform::get)

      .def_static("exists", &test_platform::exists)

      .def("is_mock", [](test_platform &p) { return p.mock_sysfs != nullptr; })

      .def_property_readonly("devices",

                             [](test_platform &p) { return p.devices; });

  ;

  py::class_<test_device> pytd(m, "test_device");

  pytd.def_property_readonly("afu_guid",

                             [](test_device &td) { return td.afu_guid; })

      .def_property_readonly("fme_guid",

                             [](test_device &td) { return td.fme_guid; });

  py::class_<test_system> pyts(m, "test_system");

  pyts.def(py::init(&test_system::instance))

      .def("initialize", &test_system::initialize)

      .def("finalize", &test_system::finalize)

      .def("prepare_sysfs", &test_system::prepare_syfs)

      .def("remove_sysfs", &test_system::remove_sysfs);

}

int run_unittest(const char *testpy, py::module pymain) {

  auto globals = py::globals();

  auto mock = py::module::import("mockopae");

  auto unit = py::module::import("unittest");

  auto scope = py::dict(pymain.attr("__dict__"));

  globals["mockopae"] = mock;

  globals["unittest"] = unit;

  try {

    py::eval_file(testpy, scope);

    auto suite = unit.attr("TestLoader")().attr("loadTestsFromModule")(pymain);

    py::dict kwargs;

    kwargs["verbosity"] = 2;

    auto runner = unit.attr("TextTestRunner")(**kwargs);

    auto result = runner.attr("run")(suite);

    return result.attr("wasSuccessful")().cast<bool>() ? 0 : 1;

  } catch (py::error_already_set &ex) {

    test_system::instance()->finalize();

    std::cerr << "error executing: " << testpy << " - " << ex.what() << "\n";

    ex.restore();

  }

  return EXIT_FAILURE;

}

int main(int argc, char *argv[]) {

  py::scoped_interpreter guard{};

  auto locals = py::dict();

  auto globals = py::globals();

  auto mopae = py::module::import("mopae");

  auto _opae = py::module::import("_opae");

  mopae.attr("fpga") = _opae;

  globals["opae"] = mopae;

  if (argc > 1) {

    auto pymain = py::module::import("__main__");

    if (argc > 2 && std::string(argv[1]) == "test") {

      return run_unittest(argv[2], pymain);

    }

    py::list pyargv;

    auto sys = py::module::import("sys");

    for (int i = 1; i < argc; ++i) {

      pyargv.append(argv[i]);

    }

    sys.attr("argv") = pyargv;

    try {

      py::eval_file(argv[1], pymain.attr("__dict__"));

    } catch (py::error_already_set &pyerr) {

      if (!pyerr.matches(PyExc_SystemExit)) {

        pyerr.restore();

      }

    }

  }

  return 0;

}