package gudusoft.gsqlparser.dlineage.dataflow.model;

/**
 * Structural identity of a node in the <strong>serialized</strong> lineage graph — the XML/JSON
 * model, where ids are {@code String} (stage S0 of
 * docs/refactor/identifier_identity_display_separation_plan.md).
 *
 * <h3>Why this is a separate type from {@link LineageNodeKey}</h3>
 * There are two identity domains and they are not interchangeable. The analysis model uses
 * immutable {@code long} ids from one shared counter; the serialized DTOs carry {@code String}
 * ids that are RENUMBERED at output time by the table-merge pass. A walker that runs after
 * serialization — {@code RoutineSummaryExtractor} is the live example — can only see the string
 * ids, so it cannot use {@code LineageNodeKey}, and a single type covering both would invite
 * keying one domain with the other's ids.
 *
 * <h3>The point of the type: id, never name</h3>
 * Serialized walkers today key nodes by {@code (parent_id, column NAME)}. That is the same defect
 * as keying by {@code (parent name, column name)} in the analysis model, just one field less
 * wrong: two projection slots of one parent that publish the same name still collapse. This type
 * keys on the column's own {@code id}, so duplicate published names stay distinct.
 *
 * <p>Renumbering is harmless here as long as both halves of a comparison come from the SAME
 * serialized document — which is the only claim this key makes. Do NOT use it to compare two
 * documents, two analyzer runs, or a baseline jar against a patched one; for that, compare
 * endpoints and topology, not ids.
 */
public final class SerializedNodeKey {

    private final String parentId;
    private final String columnId;

    private SerializedNodeKey(String parentId, String columnId) {
        this.parentId = parentId;
        this.columnId = columnId;
    }

    /**
     * @param parentId the containing object's serialized id, e.g. {@code targetColumn.getParent_id()}
     * @param columnId the column's own serialized id, e.g. {@code targetColumn.getId()}
     * @throws IllegalArgumentException if either id is null or empty. Unlike the analysis model,
     *         where any {@code long} is a legal id, an absent string id means the serializer never
     *         assigned one — so there is nothing to identify, and accepting it would merge every
     *         such node.
     */
    public static SerializedNodeKey of(String parentId, String columnId) {
        if (parentId == null || parentId.isEmpty()) {
            throw new IllegalArgumentException("serialized parent id is absent");
        }
        if (columnId == null || columnId.isEmpty()) {
            throw new IllegalArgumentException("serialized column id is absent; "
                    + "do NOT fall back to the column name — that is the defect this type removes");
        }
        return new SerializedNodeKey(parentId, columnId);
    }

    public String getParentId() {
        return parentId;
    }

    public String getColumnId() {
        return columnId;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        SerializedNodeKey that = (SerializedNodeKey) o;
        return parentId.equals(that.parentId) && columnId.equals(that.columnId);
    }

    @Override
    public int hashCode() {
        return 31 * parentId.hashCode() + columnId.hashCode();
    }

    @Override
    public String toString() {
        return "SerializedNodeKey{" + parentId + "#" + columnId + "}";
    }
}