#ifndef _APP_EDIT_HPP_
#define _APP_EDIT_HPP_

#include "core/domain/signal_type.hpp"  // SignalType

#include <string>

class Part;
class Signal;
class System;

// Application layer: UI-independent part-editing operations any frontend can
// call. No console, no dialogs, no FTXUI — Part in, result struct out.
namespace app {

// Outcome of tagging a part's connector type. The op validates the kind, sets
// the type and applies the connector model (which may materialise the layout's
// missing NC pins); the caller renders the result.
struct SetConnectorTypeResult {
    bool ok = false;
    std::string error;     ///< set when refused (kind invalid for the part)
    int materialised = 0;  ///< NC pins created from the connector layout
};

// Tag `part`'s connector type and apply the matching connector model. Refuses
// (ok=false, error set, no mutation) when the kind is invalid for the part.
SetConnectorTypeResult set_connector_type(Part *part, const std::string &kind);

// Outcome of attaching a BSDL model to a part. On success the part's pin specs
// are filled from the model and its bsdl_path is recorded.
struct AttachBsdlResult {
    bool ok = false;
    std::string error;     ///< set when the .bsd cannot be parsed
    std::string entity;    ///< the BSDL entity name
    int bound = 0;         ///< ports matched to a pin
    int unbound = 0;       ///< ports with no matching pin
    int ports_total = 0;   ///< ports declared in the model
};

// Parse the BSDL file at `path` and apply it to `part` (fills each pin's role
// and direction; records bsdl_path). Fails (ok=false, error set, no mutation)
// when the file cannot be parsed.
AttachBsdlResult attach_bsdl(Part *part, const std::string &path);

// Outcome of overriding a signal's type from a user-supplied name.
struct SetSignalTypeResult {
    bool ok = false;
    std::string error;                 ///< set when the name isn't power/gnd/other
    SignalType type = SignalType::Other;  ///< the resolved type (for rendering)
};

// Set `sig`'s type from `type_name` (power | gnd | other, case-insensitive).
// Fails (ok=false, error set, no mutation) on an unrecognised name.
SetSignalTypeResult set_signal_type(Signal *sig, const std::string &type_name);

// Outcome of cloning a module under a new name.
struct DuplicateResult {
    bool ok = false;
    std::string error;  ///< unknown source, or destination name already taken
    int parts = 0;
    int signals = 0;
};

// Deep-clone module `src_name` as `dst_name`: parts, pins (spec + nc_origin),
// signals (with type overrides) and the pin→signal wiring — but not the
// system's connections. Fails (ok=false, error set, no change) when the source
// is unknown or the destination name already exists.
DuplicateResult duplicate_module(System *sys, const std::string &src_name,
                                 const std::string &dst_name);

}  // namespace app

#endif  // _APP_EDIT_HPP_