#include <fesa/io/abaqus/semantic_mapper.hpp>

#include <algorithm>
#include <array>
#include <charconv>
#include <cstddef>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

namespace fesa {
namespace {

using LabelMap = std::map<std::int64_t, NodeId>;
using ElementLabelMap = std::map<std::int64_t, ElementId>;
using RawSetMap = std::map<std::string, std::vector<std::int64_t>, std::less<>>;

const std::string* parameter(
    const DeckRecord& record,
    const std::string_view name) {
    const auto found = record.parameters.find(name);
    return found == record.parameters.end() ? nullptr : &found->second;
}

bool is_mesh_record(const DeckRecord& record) {
    return record.keyword == "NODE" || record.keyword == "ELEMENT";
}

class DeckMapper final {
public:
    explicit DeckMapper(const ParsedDeck& deck) : deck_{deck} {}

    [[nodiscard]] DomainBuildResult map() {
        if (!select_active_scope()) {
            return failure();
        }

        collect_materials();
        collect_nodes();
        collect_raw_sets(*active_records_, false);
        if (active_assembly_ != nullptr) {
            collect_raw_sets(active_assembly_->records, true);
        }
        collect_sections();
        collect_elements();
        emit_sets();
        collect_step();

        if (!diagnostics_.empty()) {
            return failure();
        }
        return std::move(builder_).build();
    }

private:
    struct SectionAssignment final {
        MaterialId material;
        SectionId section;
    };

    [[nodiscard]] DomainBuildResult failure() {
        return {std::nullopt, std::move(diagnostics_)};
    }

    void add_error(
        std::string code,
        std::string message,
        const SourceLocation& source) {
        diagnostics_.push_back({
            DiagnosticStage::semantic,
            Severity::error,
            std::move(code),
            std::move(message),
            source,
        });
    }

    const std::string* require_parameter(
        const DeckRecord& record,
        const std::string_view name) {
        const std::string* value = parameter(record, name);
        if (value == nullptr || value->empty()) {
            add_error(
                "abaqus.semantic.missing_parameter",
                "*" + record.keyword + " requires parameter " +
                    std::string{name} + ".",
                record.source);
            return nullptr;
        }
        return value;
    }

    std::optional<std::int64_t> parse_label(
        const std::string_view text,
        const DeckRecord& record,
        const std::string_view purpose) {
        std::int64_t value = 0;
        const auto parsed =
            std::from_chars(text.data(), text.data() + text.size(), value);
        if (parsed.ec != std::errc{} ||
            parsed.ptr != text.data() + text.size() || value <= 0) {
            add_error(
                "abaqus.semantic.invalid_label",
                "Invalid " + std::string{purpose} + " label '" +
                    std::string{text} + "'.",
                record.source);
            return std::nullopt;
        }
        return value;
    }

    std::optional<std::uint8_t> parse_dof(
        const std::string_view text,
        const DeckRecord& record) {
        const std::optional<std::int64_t> value =
            parse_label(text, record, "degree-of-freedom");
        if (!value.has_value()) {
            return std::nullopt;
        }
        if (*value > 6) {
            add_error(
                "abaqus.semantic.invalid_dof",
                "Phase 1 supports only degrees of freedom 1 through 6.",
                record.source);
            return std::nullopt;
        }
        return static_cast<std::uint8_t>(*value);
    }

    std::optional<double> parse_real(
        const std::string_view text,
        const DeckRecord& record,
        const std::string_view purpose) {
        double value = 0.0;
        const auto parsed = std::from_chars(
            text.data(),
            text.data() + text.size(),
            value,
            std::chars_format::general);
        if (parsed.ec != std::errc{} ||
            parsed.ptr != text.data() + text.size()) {
            add_error(
                "abaqus.semantic.invalid_number",
                "Invalid " + std::string{purpose} + " value '" +
                    std::string{text} + "'.",
                record.source);
            return std::nullopt;
        }
        return value;
    }

    bool select_active_scope() {
        const bool has_hierarchical_input =
            !deck_.parts.empty() || deck_.assembly.has_value();
        if (!has_hierarchical_input) {
            active_records_ = &deck_.global_records;
            return true;
        }

        if (std::ranges::any_of(deck_.global_records, is_mesh_record)) {
            add_error(
                "abaqus.semantic.mixed_mesh_organization",
                "Flat mesh records cannot be mixed with Part/Assembly input.",
                std::ranges::find_if(
                    deck_.global_records, is_mesh_record)->source);
            return false;
        }
        if (!deck_.assembly.has_value()) {
            const SourceLocation source =
                deck_.parts.empty() ? SourceLocation{} : deck_.parts[0].source;
            add_error(
                "abaqus.semantic.assembly_count",
                "Hierarchical Phase 1 input requires exactly one Assembly.",
                source);
            return false;
        }

        active_assembly_ = &*deck_.assembly;
        if (active_assembly_->instances.size() != 1U) {
            const SourceLocation& source =
                active_assembly_->instances.size() > 1U
                    ? active_assembly_->instances[1].source
                    : active_assembly_->source;
            add_error(
                "abaqus.semantic.instance_count",
                "Phase 1 requires exactly one Instance.",
                source);
            return false;
        }

        const ParsedInstance& instance = active_assembly_->instances.front();
        if (!instance.transform_data.empty()) {
            add_error(
                "abaqus.semantic.instance_transform",
                "Instance translation and rotation data are unsupported.",
                instance.source);
            return false;
        }

        const auto part = std::ranges::find(
            deck_.parts, instance.part_name, &ParsedPart::name);
        if (part == deck_.parts.end()) {
            add_error(
                "abaqus.semantic.missing_part",
                "Instance '" + instance.name + "' references missing Part '" +
                    instance.part_name + "'.",
                instance.source);
            return false;
        }

        active_records_ = &part->records;
        part_name_ = part->name;
        instance_name_ = instance.name;
        return true;
    }

    void collect_materials() {
        const std::string* current_name = nullptr;
        for (const DeckRecord& record : deck_.global_records) {
            if (record.keyword == "MATERIAL") {
                current_name = require_parameter(record, "NAME");
                continue;
            }
            if (record.keyword != "ELASTIC") {
                continue;
            }
            if (current_name == nullptr) {
                add_error(
                    "abaqus.semantic.elastic_without_material",
                    "*ELASTIC requires a preceding *MATERIAL.",
                    record.source);
                continue;
            }
            if (record.data.empty() || record.data[0].size() < 2U) {
                add_error(
                    "abaqus.semantic.invalid_elastic_data",
                    "*ELASTIC requires Young's modulus and Poisson ratio.",
                    record.source);
                continue;
            }

            const auto young =
                parse_real(record.data[0][0], record, "Young's modulus");
            const auto poisson =
                parse_real(record.data[0][1], record, "Poisson ratio");
            if (!young.has_value() || !poisson.has_value()) {
                continue;
            }

            const MaterialId id{next_material_id_++};
            if (!material_ids_.emplace(*current_name, id).second) {
                add_error(
                    "abaqus.semantic.duplicate_material",
                    "Material '" + *current_name + "' is defined more than once.",
                    record.source);
                continue;
            }
            builder_.add_material({id, *current_name, *young, *poisson});
        }
    }

    void collect_nodes() {
        for (const DeckRecord& record : *active_records_) {
            if (record.keyword != "NODE") {
                continue;
            }
            for (const auto& row : record.data) {
                if (row.size() < 4U) {
                    add_error(
                        "abaqus.semantic.invalid_node_data",
                        "*NODE requires a label and three coordinates.",
                        record.source);
                    continue;
                }

                const auto label = parse_label(row[0], record, "node");
                const auto x = parse_real(row[1], record, "node coordinate");
                const auto y = parse_real(row[2], record, "node coordinate");
                const auto z = parse_real(row[3], record, "node coordinate");
                if (!label.has_value() || !x.has_value() || !y.has_value() ||
                    !z.has_value()) {
                    continue;
                }

                const NodeId id{next_node_id_++};
                node_ids_.emplace(*label, id);
                builder_.add_node({
                    id,
                    EntityOrigin{part_name_, instance_name_, *label},
                    Vec3{*x, *y, *z},
                });
            }
        }
    }

    void collect_raw_sets(
        const std::vector<DeckRecord>& records,
        const bool assembly_scope) {
        for (const DeckRecord& record : records) {
            const bool is_node_set = record.keyword == "NSET";
            const bool is_element_set = record.keyword == "ELSET";
            if (!is_node_set && !is_element_set) {
                continue;
            }

            const std::string* name =
                require_parameter(record, is_node_set ? "NSET" : "ELSET");
            if (name == nullptr) {
                continue;
            }
            if (assembly_scope) {
                const std::string* instance = parameter(record, "INSTANCE");
                if (instance == nullptr || *instance != instance_name_) {
                    add_error(
                        "abaqus.semantic.wrong_instance",
                        "Assembly set '" + *name +
                            "' must reference the active Instance.",
                        record.source);
                    continue;
                }
            }

            std::vector<std::int64_t> labels;
            for (const auto& row : record.data) {
                for (const std::string& field : row) {
                    if (field.empty()) {
                        continue;
                    }
                    const auto label =
                        parse_label(field, record, "set member");
                    if (label.has_value()) {
                        labels.push_back(*label);
                    }
                }
            }
            RawSetMap& sets = is_node_set ? raw_node_sets_ : raw_element_sets_;
            sets[*name] = std::move(labels);
        }
    }

    void collect_sections() {
        for (const DeckRecord& record : *active_records_) {
            if (record.keyword != "BEAM GENERAL SECTION") {
                continue;
            }

            const std::string* element_set =
                require_parameter(record, "ELSET");
            const std::string* material_name =
                require_parameter(record, "MATERIAL");
            if (element_set == nullptr || material_name == nullptr) {
                continue;
            }
            const auto material = material_ids_.find(*material_name);
            if (material == material_ids_.end()) {
                add_error(
                    "abaqus.semantic.missing_material",
                    "Beam section references missing Material '" +
                        *material_name + "'.",
                    record.source);
                continue;
            }
            if (record.data.size() < 2U ||
                record.data[0].size() < 5U ||
                record.data[1].size() < 3U) {
                add_error(
                    "abaqus.semantic.invalid_section_data",
                    "*BEAM GENERAL SECTION requires general properties and "
                    "an orientation vector.",
                    record.source);
                continue;
            }

            const auto area = parse_real(record.data[0][0], record, "area");
            const auto iy = parse_real(record.data[0][1], record, "Iy");
            const auto iz = parse_real(record.data[0][3], record, "Iz");
            const auto torsion =
                parse_real(record.data[0][4], record, "torsion J");
            const auto ox =
                parse_real(record.data[1][0], record, "orientation");
            const auto oy =
                parse_real(record.data[1][1], record, "orientation");
            const auto oz =
                parse_real(record.data[1][2], record, "orientation");
            if (!area.has_value() || !iy.has_value() || !iz.has_value() ||
                !torsion.has_value() || !ox.has_value() || !oy.has_value() ||
                !oz.has_value()) {
                continue;
            }

            const SectionId section_id{next_section_id_++};
            if (!section_assignments_
                     .emplace(
                         *element_set,
                         SectionAssignment{material->second, section_id})
                     .second) {
                add_error(
                    "abaqus.semantic.duplicate_section_assignment",
                    "Element set '" + *element_set +
                        "' has more than one section assignment.",
                    record.source);
                continue;
            }
            builder_.add_section({
                section_id,
                *element_set,
                *area,
                *iy,
                *iz,
                *torsion,
                5.0 * *area / 6.0,
                5.0 * *area / 6.0,
                ShearPropertySource::phase1_default,
                Vec3{*ox, *oy, *oz},
                {},
            });
        }
    }

    void collect_elements() {
        for (const DeckRecord& record : *active_records_) {
            if (record.keyword != "ELEMENT") {
                continue;
            }

            const std::string* type = require_parameter(record, "TYPE");
            const std::string* element_set =
                require_parameter(record, "ELSET");
            if (type == nullptr || element_set == nullptr) {
                continue;
            }
            if (*type != "B31") {
                add_error(
                    "abaqus.semantic.unsupported_element",
                    "Phase 1 supports only B31 elements.",
                    record.source);
                continue;
            }
            const auto assignment = section_assignments_.find(*element_set);
            if (assignment == section_assignments_.end()) {
                add_error(
                    "abaqus.semantic.missing_section",
                    "Element set '" + *element_set +
                        "' has no Beam section assignment.",
                    record.source);
                continue;
            }

            for (const auto& row : record.data) {
                if (row.size() < 3U) {
                    add_error(
                        "abaqus.semantic.invalid_element_data",
                        "B31 element data requires a label and two nodes.",
                        record.source);
                    continue;
                }
                const auto label = parse_label(row[0], record, "element");
                const auto first_label =
                    parse_label(row[1], record, "node");
                const auto second_label =
                    parse_label(row[2], record, "node");
                if (!label.has_value() || !first_label.has_value() ||
                    !second_label.has_value()) {
                    continue;
                }

                const auto first = node_ids_.find(*first_label);
                const auto second = node_ids_.find(*second_label);
                if (first == node_ids_.end() || second == node_ids_.end()) {
                    add_error(
                        "abaqus.semantic.missing_node",
                        "B31 element references a missing node label.",
                        record.source);
                    continue;
                }

                const ElementId id{next_element_id_++};
                element_ids_.emplace(*label, id);
                builder_.add_beam_element({
                    id,
                    EntityOrigin{part_name_, instance_name_, *label},
                    {first->second, second->second},
                    assignment->second.material,
                    assignment->second.section,
                });
            }
        }
    }

    template <class Id, class Lookup>
    std::vector<Id> resolve_set(
        const std::vector<std::int64_t>& labels,
        const Lookup& lookup,
        const std::string& name) {
        std::vector<Id> members;
        for (const std::int64_t label : labels) {
            const auto found = lookup.find(label);
            if (found == lookup.end()) {
                diagnostics_.push_back({
                    DiagnosticStage::semantic,
                    Severity::error,
                    "abaqus.semantic.missing_set_member",
                    "Set '" + name + "' references a missing entity label " +
                        std::to_string(label) + ".",
                    std::nullopt,
                });
                continue;
            }
            members.push_back(found->second);
        }
        std::ranges::sort(members);
        members.erase(std::ranges::unique(members).begin(), members.end());
        return members;
    }

    void emit_sets() {
        for (const auto& [name, labels] : raw_node_sets_) {
            std::vector<NodeId> members =
                resolve_set<NodeId>(labels, node_ids_, name);
            node_sets_[name] = members;
            builder_.add_node_set({name, std::move(members)});
        }
        for (const auto& [name, labels] : raw_element_sets_) {
            std::vector<ElementId> members =
                resolve_set<ElementId>(labels, element_ids_, name);
            builder_.add_element_set({name, std::move(members)});
        }
    }

    std::vector<NodeId> resolve_node_target(
        const std::string& target,
        const DeckRecord& record) {
        std::int64_t label = 0;
        const auto parsed =
            std::from_chars(target.data(), target.data() + target.size(), label);
        if (parsed.ec == std::errc{} &&
            parsed.ptr == target.data() + target.size()) {
            const auto found = node_ids_.find(label);
            if (found != node_ids_.end()) {
                return {found->second};
            }
        } else {
            const auto found = node_sets_.find(target);
            if (found != node_sets_.end()) {
                return found->second;
            }
        }

        add_error(
            "abaqus.semantic.missing_node_target",
            "Node target '" + target + "' does not resolve.",
            record.source);
        return {};
    }

    void collect_boundary(
        const DeckRecord& record,
        StepDefinition& step) {
        for (const auto& row : record.data) {
            if (row.size() < 2U) {
                add_error(
                    "abaqus.semantic.invalid_boundary_data",
                    "*BOUNDARY requires a target and degree of freedom.",
                    record.source);
                continue;
            }
            const auto first_dof = parse_dof(row[1], record);
            const auto last_dof = row.size() >= 3U && !row[2].empty()
                                      ? parse_dof(row[2], record)
                                      : first_dof;
            const auto value = row.size() >= 4U && !row[3].empty()
                                   ? parse_real(
                                         row[3], record, "prescribed value")
                                   : std::optional<double>{0.0};
            if (!first_dof.has_value() || !last_dof.has_value() ||
                !value.has_value()) {
                continue;
            }
            if (*last_dof < *first_dof) {
                add_error(
                    "abaqus.semantic.invalid_dof_range",
                    "*BOUNDARY degree-of-freedom range is reversed.",
                    record.source);
                continue;
            }

            const std::vector<NodeId> nodes =
                resolve_node_target(row[0], record);
            for (const NodeId node : nodes) {
                for (std::uint8_t dof = *first_dof; dof <= *last_dof; ++dof) {
                    step.prescribed_dofs.push_back({node, dof, *value});
                }
            }
        }
    }

    void collect_loads(
        const DeckRecord& record,
        std::map<std::int64_t, std::array<double, 6>>& loads) {
        for (const auto& row : record.data) {
            if (row.size() < 3U) {
                add_error(
                    "abaqus.semantic.invalid_cload_data",
                    "*CLOAD requires a target, degree of freedom, and value.",
                    record.source);
                continue;
            }
            const auto dof = parse_dof(row[1], record);
            const auto value = parse_real(row[2], record, "concentrated load");
            if (!dof.has_value() || !value.has_value()) {
                continue;
            }

            const std::vector<NodeId> nodes =
                resolve_node_target(row[0], record);
            for (const NodeId node : nodes) {
                loads[node.value()][static_cast<std::size_t>(*dof - 1U)] +=
                    *value;
            }
        }
    }

    void collect_step() {
        StepDefinition step;
        std::map<std::int64_t, std::array<double, 6>> loads;
        bool has_step = false;

        for (const DeckRecord& record : deck_.global_records) {
            if (record.keyword == "STEP") {
                has_step = true;
                const std::string* name = parameter(record, "NAME");
                step.name = name == nullptr ? "Step-1" : *name;
            } else if (record.keyword == "BOUNDARY") {
                collect_boundary(record, step);
            } else if (record.keyword == "CLOAD") {
                collect_loads(record, loads);
            }
        }
        if (!has_step) {
            const SourceLocation source =
                deck_.global_records.empty()
                    ? SourceLocation{}
                    : deck_.global_records.front().source;
            add_error(
                "abaqus.semantic.missing_step",
                "Phase 1 input requires one *STEP.",
                source);
            return;
        }

        for (const auto& [node, values] : loads) {
            step.nodal_loads.push_back({NodeId{node}, values});
        }
        builder_.set_step(std::move(step));
    }

    const ParsedDeck& deck_;
    DomainBuilder builder_;
    std::vector<Diagnostic> diagnostics_;
    const std::vector<DeckRecord>* active_records_ = nullptr;
    const ParsedAssembly* active_assembly_ = nullptr;
    std::string part_name_;
    std::string instance_name_;
    LabelMap node_ids_;
    ElementLabelMap element_ids_;
    std::map<std::string, MaterialId, std::less<>> material_ids_;
    std::map<std::string, SectionAssignment, std::less<>>
        section_assignments_;
    RawSetMap raw_node_sets_;
    RawSetMap raw_element_sets_;
    std::map<std::string, std::vector<NodeId>, std::less<>> node_sets_;
    std::int64_t next_node_id_ = 0;
    std::int64_t next_element_id_ = 0;
    std::int64_t next_material_id_ = 0;
    std::int64_t next_section_id_ = 0;
};

}  // namespace

DomainBuildResult map_deck_to_domain(const ParsedDeck& deck) {
    return DeckMapper{deck}.map();
}

}  // namespace fesa