/********************************************************************************
 *                                                                              *
 * This file is part of IfcOpenShell.                                           *
 *                                                                              *
 * IfcOpenShell is free software: you can redistribute it and/or modify         *
 * it under the terms of the Lesser GNU General Public License as published by  *
 * the Free Software Foundation, either version 3.0 of the License, or          *
 * (at your option) any later version.                                          *
 *                                                                              *
 * IfcOpenShell 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                 *
 * Lesser GNU General Public License for more details.                          *
 *                                                                              *
 * You should have received a copy of the Lesser GNU General Public License     *
 * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
 *                                                                              *
 ********************************************************************************/

#include "geolocation.h"
#include "geolocation_transform.h"

#include "../ifcparse/exception.h"
#include "../ifcparse/file.h"
#include "../ifcparse/instance_data.h"
#include "placement.h"
#include "pset.h"
#include "schema_dispatch.i"

#include <cmath>
#include <string>
#include <type_traits>
#include <vector>

namespace {

template <typename T>
struct is_optional : std::false_type {};

template <typename T>
struct is_optional<std::optional<T>> : std::true_type {};

template <typename Schema, typename = void>
struct is_ifc4_or_higher : std::false_type {};

template <typename Schema>
struct is_ifc4_or_higher<Schema, std::void_t<typename Schema::IfcCoordinateOperation>> : std::true_type {};

template <typename Schema, typename = void>
struct has_map_conversion_scaled : std::false_type {};

template <typename Schema>
struct has_map_conversion_scaled<Schema, std::void_t<typename Schema::IfcMapConversionScaled>> : std::true_type {};

template <typename T, typename = void>
struct has_factor_x : std::false_type {};

template <typename T>
struct has_factor_x<T, std::void_t<decltype(std::declval<T>().FactorX())>> : std::true_type {};

template <typename Schema, typename = void>
struct has_rigid_operation : std::false_type {};

template <typename Schema>
struct has_rigid_operation<Schema, std::void_t<typename Schema::IfcRigidOperation>> : std::true_type {};

[[noreturn]] void unsupported_schema(const std::string& name) {
    throw ifcopenshell::exception("No helper implementation was built for schema " + name);
}

double numeric_property(const property_map& properties,
                        const std::string& name,
                        double fallback) {
    const auto found = properties.find(name);
    if (found == properties.end()) {
        return fallback;
    }
    if (const auto value = found->second.get_if<double>()) {
        return *value;
    }
    if (const auto value = found->second.get_if<std::int64_t>()) {
        return static_cast<double>(*value);
    }
    return fallback;
}

double selected_number(const express::base& selected, double fallback) {
    if (!selected) {
        return fallback;
    }
    const auto value = selected.get_attribute_value(0);
    if (value.isNull()) {
        return fallback;
    }
    if (value.type() == ifcopenshell::Argument_DOUBLE) {
        return static_cast<double>(value);
    }
    if (value.type() == ifcopenshell::Argument_INT) {
        return static_cast<double>(static_cast<int64_t>(value));
    }
    return fallback;
}

template <typename T>
double optional_number(const T& value, double fallback) {
    if constexpr (is_optional<T>::value) {
        return value.value_or(fallback);
    } else {
        return value;
    }
}

template <typename Schema>
std::optional<HelmertTransformation> get_helmert_transformation_parameters_s(ifcopenshell::file* ifc_file) {
    HelmertTransformation result;
    if constexpr (!is_ifc4_or_higher<Schema>::value) {
        const auto projects = ifc_file->template instances_by_type<typename Schema::IfcProject>();
        if (projects.empty()) {
            return std::nullopt;
        }
        const auto conversion = get_pset(projects.front(), "ePSet_MapConversion");
        if (!conversion) {
            return std::nullopt;
        }
        const auto* properties = conversion->template get_if<property_map>();
        if (!properties) {
            return std::nullopt;
        }
        result.e = numeric_property(*properties, "Eastings", 0.0);
        result.n = numeric_property(*properties, "Northings", 0.0);
        result.h = numeric_property(*properties, "OrthogonalHeight", 0.0);
        result.xaa = numeric_property(*properties, "XAxisAbscissa", 0.0);
        result.xao = numeric_property(*properties, "XAxisOrdinate", 0.0);
        result.scale = numeric_property(*properties, "Scale", 1.0);
    } else {
        const auto conversions =
            ifc_file->template instances_by_type<typename Schema::IfcCoordinateOperation>();
        if (conversions.empty()) {
            return std::nullopt;
        }
        const auto& conversion = conversions.front();
        if (auto map_conversion = conversion.template as<typename Schema::IfcMapConversion>()) {
            result.e = map_conversion.Eastings();
            result.n = map_conversion.Northings();
            result.h = map_conversion.OrthogonalHeight();
            result.xaa = map_conversion.XAxisAbscissa().value_or(0.0);
            result.xao = map_conversion.XAxisOrdinate().value_or(0.0);
            result.scale = map_conversion.Scale().value_or(1.0);
            if constexpr (has_map_conversion_scaled<Schema>::value) {
                if (auto scaled = conversion.template as<typename Schema::IfcMapConversionScaled>()) {
                    if constexpr (has_factor_x<decltype(scaled)>::value) {
                        result.factor_x = scaled.FactorX();
                        result.factor_y = scaled.FactorY();
                        result.factor_z = scaled.FactorZ();
                    } else {
                        result.factor_x = scaled.ScaleX();
                        result.factor_y = scaled.ScaleY();
                        result.factor_z = scaled.ScaleZ();
                    }
                }
            }
        } else if constexpr (has_rigid_operation<Schema>::value) {
            if (auto rigid = conversion.template as<typename Schema::IfcRigidOperation>()) {
                result.e = selected_number(rigid.FirstCoordinate().concrete(), 0.0);
                result.n = selected_number(rigid.SecondCoordinate().concrete(), 0.0);
                result.h = optional_number(rigid.Height(), 0.0);
            } else {
                return std::nullopt;
            }
        } else {
            return std::nullopt;
        }
    }

    if (result.scale == 0.0) {
        result.scale = 1.0;
    }
    if (result.xaa == 0.0 && result.xao == 0.0) {
        result.xaa = 1.0;
    }
    return result;
}

template <typename Schema>
std::optional<Eigen::Matrix4d> get_wcs_s(ifcopenshell::file* ifc_file) {
    const auto contexts =
        ifc_file->template instances_by_type_excl_subtypes<typename Schema::IfcGeometricRepresentationContext>();
    express::base wcs;
    for (const auto& context : contexts) {
        const auto placement = context.WorldCoordinateSystem();
        if (!placement) {
            continue;
        }
        wcs = placement.concrete();
        if (context.ContextType() == std::optional<std::string>("Model")) {
            break;
        }
    }
    if (!wcs) {
        return std::nullopt;
    }
    return get_axis2_placement(wcs);
}

template <typename Schema>
std::optional<express::base> get_map_unit_s(ifcopenshell::file* ifc_file) {
    if constexpr (!is_ifc4_or_higher<Schema>::value) {
        return std::nullopt;
    } else {
        const auto operations =
            ifc_file->template instances_by_type<typename Schema::IfcCoordinateOperation>();
        if (operations.empty()) {
            return std::nullopt;
        }
        const auto target = operations.front().TargetCRS();
        const auto projected = target.template as<typename Schema::IfcProjectedCRS>();
        if (!projected) {
            return std::nullopt;
        }
        const auto unit = projected.MapUnit();
        if (!unit) {
            return std::nullopt;
        }
        return unit;
    }
}

} // namespace

std::optional<HelmertTransformation>
get_helmert_transformation_parameters(ifcopenshell::file* ifc_file) {
    const auto name = ifc_file->schema()->name();
#define IFCOPENSHELL_DISPATCH(Schema, Identifier) \
    if (name == Identifier)                       \
        return get_helmert_transformation_parameters_s<Schema>(ifc_file);
    IFCOPENSHELL_HELPER_FOR_EACH_SCHEMA(IFCOPENSHELL_DISPATCH)
#undef IFCOPENSHELL_DISPATCH
    unsupported_schema(name);
}

std::optional<Eigen::Matrix4d> get_wcs(ifcopenshell::file* ifc_file) {
    const auto name = ifc_file->schema()->name();
#define IFCOPENSHELL_DISPATCH(Schema, Identifier) \
    if (name == Identifier)                       \
        return get_wcs_s<Schema>(ifc_file);
    IFCOPENSHELL_HELPER_FOR_EACH_SCHEMA(IFCOPENSHELL_DISPATCH)
#undef IFCOPENSHELL_DISPATCH
    unsupported_schema(name);
}

Eigen::Matrix4d auto_local_to_global(ifcopenshell::file* ifc_file,
                                     const Eigen::Matrix4d& matrix,
                                     bool should_return_in_map_units) {
    auto params = get_helmert_transformation_parameters(ifc_file);
    if (!params) {
        return matrix;
    }

    Eigen::Matrix4d m = matrix;
    if (auto wcs = get_wcs(ifc_file)) {
        m = wcs->inverse() * m;
    }
    Eigen::Matrix4d result = local_to_global(m, *params);
    if (!should_return_in_map_units) {
        result(0, 3) /= params->scale;
        result(1, 3) /= params->scale;
        result(2, 3) /= params->scale;
    }
    return result;
}

std::optional<express::base> get_map_unit(ifcopenshell::file* ifc_file) {
    const auto name = ifc_file->schema()->name();
#define IFCOPENSHELL_DISPATCH(Schema, Identifier) \
    if (name == Identifier)                       \
        return get_map_unit_s<Schema>(ifc_file);
    IFCOPENSHELL_HELPER_FOR_EACH_SCHEMA(IFCOPENSHELL_DISPATCH)
#undef IFCOPENSHELL_DISPATCH
    unsupported_schema(name);
}