#!/usr/bin/env python3
"""Genera RDF/OWL y datasets desde data/iom_spec.json, única fuente tabular."""
from __future__ import annotations

import csv
import json
from pathlib import Path
from rdflib import BNode, Graph, Literal, Namespace
from rdflib.namespace import OWL, RDF, RDFS, XSD

ROOT = Path(__file__).resolve().parents[1]
SPEC = json.loads((ROOT / "data" / "iom_spec.json").read_text(encoding="utf-8"))
IO = Namespace("http://example.org/iom#")
g = Graph()
for prefix, namespace in (("io", IO), ("rdfs", RDFS), ("xsd", XSD), ("owl", OWL)):
    g.bind(prefix, namespace)

ontology = IO.Ontology
g.add((ontology, RDF.type, OWL.Ontology))
g.add((ontology, OWL.versionInfo, Literal(SPEC["spec_version"])))
g.add((ontology, RDFS.label, Literal("Ontología IOM", lang="es")))
g.add((ontology, RDFS.comment, Literal(SPEC["source_note"], lang="es")))
classes = ("OntoNode", "VectorStep", "Perspective", "ExpandedCategory", "Position", "Direction", "SourceModel")
for name in classes:
    g.add((IO[name], RDF.type, OWL.Class))
for names in (("OntoNode", "VectorStep", "ExpandedCategory", "Perspective"),):
    axiom = BNode("iomDisjointCoreClasses")
    head = BNode("iomDisjointClassList0")
    g.add((axiom, RDF.type, OWL.AllDisjointClasses))
    g.add((axiom, OWL.members, head))
    cells = [BNode(f"iomDisjointClassList{i}") for i in range(len(names))]
    for index, name in enumerate(names):
        g.add((cells[index], RDF.first, IO[name]))
        g.add((cells[index], RDF.rest, cells[index + 1] if index + 1 < len(cells) else RDF.nil))

object_properties = {
    "hasPerspective": ("OntoNode", "Perspective"),
    "hasPosition": ("OntoNode", "Position"),
    "hasDirection": ("OntoNode", "Direction"),
    "hasVector": ("VectorStep", "Perspective"),
    "mirrorOf": ("OntoNode", "OntoNode"),
    "creates": ("OntoNode", "OntoNode"),
}
datatype_properties = {
    "hasTriadIndex": ("OntoNode", XSD.integer),
    "hasPhase": ("OntoNode", XSD.string),
    "hasLocalPos": ("OntoNode", XSD.integer),
    "displayLabel": ("OntoNode", XSD.string),
    "hasCyclePhase": ("VectorStep", XSD.string),
    "hasAxisPosition": ("VectorStep", XSD.integer),
    "hasStepIndex": ("VectorStep", XSD.integer),
    "displayArrow": ("VectorStep", XSD.string),
    "hasLevel": ("ExpandedCategory", XSD.integer),
    "declaredTriadCount": ("SourceModel", XSD.integer),
    "declaredPerspectiveCount": ("SourceModel", XSD.integer),
    "declaredOperatorCount": ("SourceModel", XSD.integer),
    "declaredExpandedCategoryCount": ("SourceModel", XSD.integer),
}
for name, (domain, range_) in object_properties.items():
    prop = IO[name]
    g.add((prop, RDF.type, OWL.ObjectProperty))
    g.add((prop, RDFS.domain, IO[domain]))
    g.add((prop, RDFS.range, IO[range_]))
for name, (domain, range_) in datatype_properties.items():
    prop = IO[name]
    g.add((prop, RDF.type, OWL.DatatypeProperty))
    g.add((prop, RDFS.domain, IO[domain]))
    g.add((prop, RDFS.range, range_))
for name in ("hasPerspective", "hasPosition", "hasDirection", "hasVector", "hasTriadIndex", "hasPhase", "hasLocalPos", "displayLabel", "hasCyclePhase", "hasAxisPosition", "hasStepIndex", "displayArrow", "hasLevel"):
    g.add((IO[name], RDF.type, OWL.FunctionalProperty))
g.add((IO.mirrorOf, RDF.type, OWL.SymmetricProperty))

for pos, label in [("→", "→"), ("0", "0"), ("←", "←")]:
    g.add((IO[pos], RDF.type, OWL.NamedIndividual))
    g.add((IO[pos], RDF.type, IO.Position))
    g.add((IO[pos], RDFS.label, Literal(label, lang="es")))
for direction in ("evol", "invol"):
    g.add((IO[direction], RDF.type, OWL.NamedIndividual))
    g.add((IO[direction], RDF.type, IO.Direction))
_perspective_labels = SPEC.get("perspective_labels") or {
    "Ind": "Individualidad", "D": "Dualidad", "Tot": "Totalidad",
    "Evol": "Evolución", "Invol": "Involución",
}
for name, label in _perspective_labels.items():
    g.add((IO[name], RDF.type, IO.Perspective))
    g.add((IO[name], RDFS.label, Literal(label, lang="es")))

position_meta = SPEC["positions"]
position_indices = position_meta["indices"]
position_names_adv = ["→", "0", "→"]
position_names_ret = ["←", "0", "←"]
perspective_names = position_meta["perspectives"]
perspectives = [IO[name] for name in perspective_names]
triad_meta = SPEC["triads"]
triad_rows = {phase: triad_meta[phase] for phase in ("adv", "ret")}
index_base = triad_meta.get("index_base", 0)
n_triads = len(triad_rows["adv"])
triad_ids = range(index_base, index_base + n_triads)
nodes_csv = []
for phase, rows in triad_rows.items():
    direction = IO[SPEC["phases"][phase]["direction"]]
    for row_index, labels in enumerate(rows):
        triad_idx = index_base + row_index
        for pos_idx, label in enumerate(labels):
            node = IO[f"T{triad_idx:02d}_{phase}_P{pos_idx}"]
            g.add((node, RDF.type, IO.OntoNode))
            g.add((node, IO.hasTriadIndex, Literal(triad_idx, datatype=XSD.integer)))
            g.add((node, IO.hasPhase, Literal(phase, datatype=XSD.string)))
            g.add((node, IO.hasLocalPos, Literal(pos_idx, datatype=XSD.integer)))
            display_labels = position_meta["adv_labels" if phase == "adv" else "ret_labels"]
            display_label = display_labels[pos_idx]
            g.add((node, IO.displayLabel, Literal(display_label, datatype=XSD.string)))
            pos_names = position_names_adv if phase == "adv" else position_names_ret
            g.add((node, IO.hasPosition, IO[pos_names[pos_idx]]))
            g.add((node, IO.hasPerspective, perspectives[pos_idx]))
            g.add((node, IO.hasDirection, direction))
            g.add((node, RDFS.label, Literal(label, lang="es")))
            nodes_csv.append({"node_id": str(node).split("#", 1)[1], "triad_index": triad_idx, "phase": phase,
                              "direction": str(direction).split("#", 1)[1], "position_index": pos_idx,
                              "position": pos_names[pos_idx], "display_label": display_label,
                              "perspective": perspective_names[pos_idx], "label": label})

for triad_idx in triad_ids:
    for pos_idx in range(3):
        adv = IO[f"T{triad_idx:02d}_adv_P{pos_idx}"]
        ret = IO[f"T{triad_idx:02d}_ret_P{2-pos_idx}"]
        g.add((adv, IO.mirrorOf, ret))
        g.add((ret, IO.mirrorOf, adv))

for triad_idx in triad_ids:
    for rule in SPEC["creation_rules"]:
        for source_pos in rule["source_positions"]:
            for target_pos in rule["target_positions"]:
                source = IO[f"T{triad_idx:02d}_{rule['source_phase']}_P{source_pos}"]
                target = IO[f"T{triad_idx:02d}_{rule['target_phase']}_P{target_pos}"]
                g.add((source, IO.creates, target))

vector_csv = []
for vector_row in SPEC["vectors"]:
    vector, phase = vector_row["name"], vector_row["phase"]
    for step_index, (label, axis_pos) in enumerate(zip(vector_row["labels"], vector_row["axis_positions"])):
        step = IO[f"vector_{vector.lower()}_{phase}_{step_index}"]
        g.add((step, RDF.type, IO.VectorStep))
        g.add((step, IO.hasVector, IO[vector]))
        g.add((step, IO.hasCyclePhase, Literal(phase, datatype=XSD.string)))
        g.add((step, IO.hasAxisPosition, Literal(axis_pos, datatype=XSD.integer)))
        g.add((step, IO.hasStepIndex, Literal(step_index, datatype=XSD.integer)))
        g.add((step, IO.displayArrow, Literal(vector_row["arrow"], datatype=XSD.string)))
        g.add((step, RDFS.label, Literal(label, lang="es")))
        vector_csv.append({"step_id": str(step).split("#", 1)[1], "vector": vector, "phase": phase,
                           "step_index": step_index, "axis_position": axis_pos, "label": label,
                           "arrow": vector_row["arrow"]})

for level, labels in SPEC["expanded_categories"].items():
    for index, label in enumerate(labels, 1):
        category = IO[f"expanded_L{level}_{index:02d}"]
        g.add((category, RDF.type, IO.ExpandedCategory))
        g.add((category, IO.hasLevel, Literal(int(level), datatype=XSD.integer)))
        g.add((category, RDFS.label, Literal(label, lang="es")))

model = IO.SourceModel
g.add((model, RDF.type, IO.SourceModel))
for prop, value in ((IO.declaredTriadCount, 13), (IO.declaredPerspectiveCount, 5),
                    (IO.declaredOperatorCount, 4), (IO.declaredExpandedCategoryCount, 21)):
    g.add((model, prop, Literal(value, datatype=XSD.integer)))

relation_csv = []
relation_lookup = {}
for subject, _, obj in g.triples((None, IO.mirrorOf, None)):
    relation_lookup[(str(subject), str(obj))] = "mirrorOf"
for subject, _, obj in g.triples((None, IO.creates, None)):
    relation_lookup[(str(subject), str(obj))] = "creates"
for triad_idx in triad_ids:
    ids = [IO[f"T{triad_idx:02d}_{phase}_P{pos}"] for phase in ("adv", "ret") for pos in range(3)]
    for source in ids:
        for target in ids:
            if source == target:
                continue
            relation_csv.append({"triad_index": triad_idx, "source": str(source).split("#", 1)[1],
                                 "target": str(target).split("#", 1)[1],
                                 "relation": relation_lookup.get((str(source), str(target)), "none")})

assert len(triad_rows["adv"]) == len(triad_rows["ret"]) == 13
assert position_indices == [0, 1, 2]
assert len(nodes_csv) == 78
assert len(vector_csv) == 20
assert sum(1 for _ in g.triples((None, IO.creates, None))) == 104
assert len(relation_csv) == 13 * 6 * 5

out = ROOT / "ontology" / "io_ontology.ttl"
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(g.serialize(format="turtle").rstrip() + "\n", encoding="utf-8")

def write_csv(path: Path, rows: list[dict]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0]), lineterminator="\n")
        writer.writeheader()
        writer.writerows(rows)

write_csv(ROOT / "datasets" / "triad_nodes.csv", nodes_csv)
write_csv(ROOT / "datasets" / "vector_steps.csv", vector_csv)
write_csv(ROOT / "datasets" / "relation_candidates.csv", relation_csv)

_stamp = {
    "spec_version": SPEC["spec_version"],
    "schema_version": SPEC.get("schema_version"),
    "source_date": SPEC.get("source_date"),
    "purpose_id": (SPEC.get("purpose") or {}).get("id"),
    "purpose_label": (SPEC.get("purpose") or {}).get("label"),
    "artifacts": [
        "datasets/triad_nodes.csv",
        "datasets/vector_steps.csv",
        "datasets/relation_candidates.csv",
        "ontology/io_ontology.ttl",
    ],
}
(ROOT / "datasets" / "GENERATED_FROM.json").write_text(
    json.dumps(_stamp, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Tríadas: {n_triads} por fase (índice {index_base}–{index_base + n_triads - 1}); nodos: {len(nodes_csv)}; creates: 104; espejos: 78")
print(f"Pasos vectoriales: {len(vector_csv)}; candidatos PI-HGAT-T: {len(relation_csv)}")
print(f"OWL/Turtle: {out}")
print(f"Sello: datasets/GENERATED_FROM.json spec_version={SPEC['spec_version']}")