// SPDX-License-Identifier: LGPL-2.1-or-later

/****************************************************************************
 *   Copyright (c) 2017 Zheng Lei (realthunder) <realthunder.dev@gmail.com> *
 *                                                                          *
 *   This file is part of the FreeCAD CAx development system.               *
 *                                                                          *
 *   This library is free software; you can redistribute it and/or          *
 *   modify it under the terms of the GNU Library General Public            *
 *   License as published by the Free Software Foundation; either           *
 *   version 2 of the License, or (at your option) any later version.       *
 *                                                                          *
 *   This library  is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *   GNU Library General Public License for more details.                   *
 *                                                                          *
 *   You should have received a copy of the GNU Library General Public      *
 *   License along with this library; see the file COPYING.LIB. If not,     *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,          *
 *   Suite 330, Boston, MA  02111-1307, USA                                 *
 *                                                                          *
 ****************************************************************************/

#include <sstream>

#include "DocumentObjectPy.h"
#include "LinkBaseExtensionPy.h"
#include "LinkBaseExtensionPy.cpp"

using namespace App;

// returns a string which represent the object e.g. when printed in python
std::string LinkBaseExtensionPy::representation() const
{
    std::ostringstream str;
    str << "<" << getLinkBaseExtensionPtr()->getExtensionClassTypeId().getName() << ">";
    return str.str();
}

using PropTmpMap = std::map<std::string, std::pair<int, Property*>>;
using PropMap = std::map<std::string, Property*>;

static bool getProperty(PropTmpMap& props,
                        const LinkBaseExtension::PropInfoMap& infoMap,
                        const PropMap& propMap,
                        PyObject* key,
                        PyObject* value)
{
    std::ostringstream str;

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(PyExc_TypeError, "key must be a unicode string");
        return false;
    }
    const char* keyStr = PyUnicode_AsUTF8(key);
    auto it = infoMap.find(keyStr);
    if (it == infoMap.end()) {
        str << "unknown key '" << keyStr << "'";
        PyErr_SetString(PyExc_KeyError, str.str().c_str());
        return false;
    }

    const char* valStr = nullptr;
    if (key == value) {
        valStr = keyStr;
    }
    else if (value != Py_None) {
        if (!PyUnicode_Check(value)) {
            PyErr_SetString(PyExc_TypeError, "value must be unicode string");
            return false;
        }
        valStr = PyUnicode_AsUTF8(value);
    }

    App::Property* prop = nullptr;
    auto& info = it->second;
    if (valStr) {
        auto pIt = propMap.find(valStr);
        if (pIt == propMap.end()) {
            str << "cannot find property '" << valStr << "'";
            PyErr_SetString(PyExc_ValueError, str.str().c_str());
            return false;
        }
        prop = pIt->second;
        if (!prop->isDerivedFrom(info.type)) {
            str << "expect property '" << keyStr << "(" << valStr << ") to be derived from '"
                << info.type.getName() << "', instead of '" << prop->getTypeId().getName() << "'";
            PyErr_SetString(PyExc_TypeError, str.str().c_str());
        }
    }
    props[keyStr] = std::make_pair(info.index, prop);
    return true;
}

PyObject* LinkBaseExtensionPy::configLinkProperty(PyObject* args, PyObject* keywds)
{
    auto ext = getLinkBaseExtensionPtr();
    const auto& info = ext->getPropertyInfoMap();

    PropMap propMap;
    ext->getExtendedContainer()->getPropertyMap(propMap);

    PropTmpMap props;

    if (args && PyTuple_Check(args)) {
        for (Py_ssize_t pos = 0; pos < PyTuple_GET_SIZE(args); ++pos) {
            auto key = PyTuple_GET_ITEM(args, pos);
            if (!getProperty(props, info, propMap, key, key)) {
                return nullptr;
            }
        }
    }
    if (keywds && PyDict_Check(keywds)) {
        PyObject *key, *value;
        Py_ssize_t pos = 0;
        while (PyDict_Next(keywds, &pos, &key, &value)) {
            if (!getProperty(props, info, propMap, key, value)) {
                return nullptr;
            }
        }
    }
    for (auto& v : props) {
        ext->setProperty(v.second.first, v.second.second);
    }
    Py_Return;
}

PyObject* LinkBaseExtensionPy::getLinkExtProperty(PyObject* args)
{
    const char* name;
    if (!PyArg_ParseTuple(args, "s", &name)) {
        return nullptr;
    }
    auto prop = getLinkBaseExtensionPtr()->getProperty(name);
    if (!prop) {
        PyErr_SetString(PyExc_AttributeError, "unknown property name");
        return nullptr;
    }
    return prop->getPyObject();
}

PyObject* LinkBaseExtensionPy::getLinkExtPropertyName(PyObject* args)
{
    const char* name;
    if (!PyArg_ParseTuple(args, "s", &name)) {
        return nullptr;
    }
    auto prop = getLinkBaseExtensionPtr()->getProperty(name);
    if (!prop) {
        PyErr_SetString(PyExc_AttributeError, "unknown property name");
        return nullptr;
    }
    auto container = getLinkBaseExtensionPtr()->getExtendedContainer();
    if (!container) {
        PyErr_SetString(PyExc_RuntimeError, "no extended container");
        return nullptr;
    }
    name = container->getPropertyName(prop);
    if (!name) {
        PyErr_SetString(PyExc_RuntimeError, "cannot find property name");
        return nullptr;
    }
    return Py::new_reference_to(Py::String(name));
}

PyObject* LinkBaseExtensionPy::getLinkPropertyInfo(PyObject* args)
{
    auto ext = getLinkBaseExtensionPtr();

    const auto& infos = ext->getPropertyInfo();

    if (PyArg_ParseTuple(args, "")) {
        Py::Tuple ret(infos.size());
        int i = 0;
        for (const auto& info : infos) {
            ret.setItem(i++,
                        Py::TupleN(Py::String(info.name),
                                   Py::String(info.type.getName()),
                                   Py::String(info.doc)));
        }
        return Py::new_reference_to(ret);
    }

    short index = 0;
    if (PyArg_ParseTuple(args, "h", &index)) {
        if (index < 0 || index >= (int)infos.size()) {
            PyErr_SetString(PyExc_ValueError, "index out of range");
            return nullptr;
        }
        Py::TupleN ret(Py::String(infos[index].name),
                       Py::String(infos[index].type.getName()),
                       Py::String(infos[index].doc));
        return Py::new_reference_to(ret);
    }

    char* name;
    if (PyArg_ParseTuple(args, "s", &name)) {
        for (const auto& info : infos) {
            if (strcmp(info.name, name) == 0) {
                Py::TupleN ret(Py::String(info.type.getName()), Py::String(info.doc));
                return Py::new_reference_to(ret);
            }
        }
        PyErr_SetString(PyExc_ValueError, "unknown property name");
        return nullptr;
    }

    PyErr_SetString(PyExc_ValueError, "invalid arguments");
    return nullptr;
}

void parseLink(LinkBaseExtension* ext, int index, PyObject* value)
{
    App::DocumentObject* obj = nullptr;
    PropertyStringList subs;
    PropertyString sub;
    if (value != Py_None) {
        if (PyObject_TypeCheck(value, &DocumentObjectPy::Type)) {
            obj = static_cast<DocumentObjectPy*>(value)->getDocumentObjectPtr();
        }
        else if (!PySequence_Check(value)) {
            throw Base::TypeError("Expects type of DocumentObject or sequence");
        }
        else {
            Py::Sequence seq(value);
            if (seq[0].ptr() != Py_None) {
                if (!PyObject_TypeCheck(seq[0].ptr(), &DocumentObjectPy::Type)) {
                    throw Base::TypeError(
                        "Expects the first argument to be DocumentObject in sequence");
                }
                obj = static_cast<DocumentObjectPy*>(seq[0].ptr())->getDocumentObjectPtr();
                if (seq.size() > 1) {
                    sub.setPyObject(seq[1].ptr());
                    if (seq.size() > 2) {
                        subs.setPyObject(seq[2].ptr());
                    }
                }
            }
        }
    }
    ext->setLink(index, obj, sub.getValue(), subs.getValue());
}

PyObject* LinkBaseExtensionPy::setLink(PyObject* _args)
{
    Py::Sequence args(_args);
    PY_TRY
    {
        auto ext = getLinkBaseExtensionPtr();
        PyObject* pcObj = args.size() ? args[0].ptr() : Py_None;
        if (pcObj == Py_None) {
            ext->setLink(-1, nullptr);
        }
        else if (PyDict_Check(pcObj)) {
            PyObject *key, *value;
            Py_ssize_t pos = 0;
            while (PyDict_Next(pcObj, &pos, &key, &value)) {
                parseLink(ext, Py::Long(key), value);
            }
        }
        else if (PySequence_Check(pcObj)) {
            ext->setLink(-1, nullptr);
            Py::Sequence seq(pcObj);
            for (Py_ssize_t i = 0; i < seq.size(); ++i) {
                parseLink(ext, i, seq[i].ptr());
            }
        }
        else {
            parseLink(ext, -1, _args);
        }

        Py_Return;
    }
    PY_CATCH
}

PyObject* LinkBaseExtensionPy::cacheChildLabel(PyObject* args)
{
    PyObject* enable = Py_True;
    if (!PyArg_ParseTuple(args, "|O", &enable)) {
        return nullptr;
    }
    PY_TRY
    {
        getLinkBaseExtensionPtr()->cacheChildLabel(Base::asBoolean(enable) ? -1 : 0);
        Py_Return;
    }
    PY_CATCH;
}

PyObject* LinkBaseExtensionPy::flattenSubname(PyObject* args)
{
    const char* subname;
    if (!PyArg_ParseTuple(args, "s", &subname)) {
        return nullptr;
    }
    PY_TRY
    {
        return Py::new_reference_to(Py::String(getLinkBaseExtensionPtr()->flattenSubname(subname)));
    }
    PY_CATCH;
}

PyObject* LinkBaseExtensionPy::expandSubname(PyObject* args)
{
    const char* subname;
    if (!PyArg_ParseTuple(args, "s", &subname)) {
        return nullptr;
    }
    PY_TRY
    {
        std::string sub(subname);
        getLinkBaseExtensionPtr()->expandSubname(sub);
        return Py::new_reference_to(Py::String(sub));
    }
    PY_CATCH;
}

Py::List LinkBaseExtensionPy::getLinkedChildren() const
{
    Py::List ret;
    for (auto o : getLinkBaseExtensionPtr()->getLinkedChildren(true)) {
        ret.append(Py::asObject(o->getPyObject()));
    }
    return ret;
}

PyObject* LinkBaseExtensionPy::getCustomAttributes(const char* /*attr*/) const
{
    return nullptr;
}

int LinkBaseExtensionPy::setCustomAttributes(const char* /*attr*/, PyObject* /*obj*/)
{
    return 0;
}