import { PAG_LANGUAGE } from "#configuration/constants/code.constants";
import { STRUCTURE_SECTION_ICON } from "#configuration/icons/grammar.icons";
import { STRUCTURE_SECTION_ID } from "#core/ids/grammar.ids";
import type { Section } from "#types/document.types";

const SKELETON =
    '---\nname: <document-name>\ntype: WORKFLOW\nversion: 1.0.0\n---\n\nTHIS WORKFLOW EXECUTES <what it is for>\n\n%% META %%:\n    priority: <what outranks what when two sources disagree>\n    trust: <what is trusted> = TRUSTED, <what is not> = UNTRUSTED\n    objective: "<what finished looks like, checkable>"\n    jurisdiction: <what the document may touch> | external: <what it declares outside itself>\n    recursion_limit: <a bound on repair>\n\n# THE FOUR LAYERS · each answers one question about this document\n#   substrate  — how does the artifact come to be        grounds the order of the nodes, named on each by @genesis\n#   epistemic  — how is it known                          orient · see · derive · project · act\n#   conative   — what is worth doing                      intent · constrain            mandatory, always\n#   evaluative — is it right, and are we done             verify · commit · terminate   mandatory, always\n\n# YIELDS-SHAPE LEGEND · every decision resolves to a typed shape\n#   set-theory -> set|boolean · logic -> boolean · graph -> edge-list · optimisation -> boolean|ranking · computation -> procedure\n\n# SEMANTIC OPERATION BOUNDARY · nodes say WHAT as operations; an adapter decides HOW, and the core names no tool or path\n\n# THE LOOP SPINE · transitions declared once, every node cites it\n# node · layer · axis · yields · transition out\n\n# NODE 1 — ORIENT … NODE 10 — TERMINATE · each with its four-slot tag, its genesis stage, its contract and one evidence-bearing gate\n\n# REPAIR EDGE · verify refutes back to the earliest invalid node, bounded by recursion_limit\n\n# CROSS-NODE INVARIANTS\nINVARIANT <name>: <a property that could be false> over: <the set it ranges over> binds: <the parties it constrains> objector: <the check that would disagree | none>\n\nREPORT:\n  subject: <the terminal node>\n  verdict: pass | fail | unknown\n  domain: declared <N> measured <n>\n  completion: saturated <bool> complete <bool> verified <bool>';

const TYPE_SHAPE =
    "# a type binds a document to a reasoning model and to the axis of the loop it sits on\n\n# cognition · how a system perceives, acts and adapts\nTHIS AGENT PERFORMS <a behaviour, walked as nodes>                axis: reasoning\nTHIS WORKFLOW EXECUTES <a multi-node process>                    axis: formalisation\nTHIS PROMPT IS <one interaction>                                 axis: formalisation\nTHIS COMMAND EXECUTES <one invocable operation>                  axis: formalisation\n\n# pattern-cycle · how pattern-work proceeds\nTHIS PROTOCOL DEFINES <a standing procedure, as rules>           axis: formalisation\nTHIS CHECKLIST PROVIDES <tasks with their contracts>             axis: formalisation\nTHIS TASK EXECUTES <one objective>                               axis: formalisation\nTHIS INSTRUCTION IS <general guidance>                           axis: formalisation\nTHIS COMPOSITION RENDERS <a structure from anchors and modifiers> axis: formalisation\nTHIS POLICY ENFORCES <a constraint set>                          axis: teleology\nTHIS TEMPLATE IMPLEMENTS <a reusable shape, slots open>          axis: representation\n\n# epistemology · how a pattern is known\nTHIS TEST PERFORMS <a specification checked by running it>       axis: verification\nTHIS VERIFICATION PERFORMS <claims adjudicated against evidence> axis: verification\nTHIS AUDIT AUDITS <an artifact against a contract, then corrects> axis: verification\nTHIS DEBUG RESOLVES <a symptom to an evidence-scored cause>      axis: analysis\nTHIS DISTILLATION DISTILLS <repeated behaviour into one base>    axis: reasoning\nTHIS TRANSLATION AUDITS <a rendering against its source>         axis: representation";

const ORDER_DIAGRAM =
    'flowchart TB\n    front["Header block · name, type, version"]\n    decl["Declaration · THIS TYPE VERB description"]\n    meta["META · priority, trust, objective, bounds"]\n    frame["The four layers, the shape legend, the operation boundary"]\n    substrate["The substrate · how the artifact comes to be"]\n    spine["The spine · transitions declared once"]\n    nodes["Nodes · each with a contract and one gate"]\n    repair["The repair edge · bounded"]\n    rules["Cross-node invariants · one record each"]\n    report["The report · what was measured, over what, and whether the three conditions coincide"]\n    front --> decl --> meta --> frame --> substrate --> spine --> nodes --> repair --> rules --> report';

const TYPE_DIAGRAM =
    'flowchart LR\n    type["The declared type"]\n    verb["Its default verb"]\n    model["The reasoning model that walks it"]\n    axis["The axis of the loop it sits on"]\n    reader["A reader knows what kind of instruction this is, and what will walk it"]\n    type --> verb --> reader\n    type --> model --> reader\n    type --> axis --> reader';

export const STRUCTURE_SECTION: Section = {
    icon: STRUCTURE_SECTION_ICON,
    id: STRUCTURE_SECTION_ID,
    intro: "A document announces what kind of instruction it is before it instructs, which is the orient stage of the loop written down: what exists is declared before anything is done with it. A document is a self-describing structure, laid out as <cite>skeleton</cite> and ordered as <cite>parts in order</cite> draws, and one that opens with a directive has left its own contract implicit. The type it declares is one of <cite>the types</cite>, and <cite>what a type fixes</cite> is what that one line settles before any node is walked.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "Declare before instructing: the header, the declaration, the meta block, then the frame the nodes cite, and close with the repair edge and the invariants.",
                    boundary:
                        "A fragment reused inside other documents carries no header of its own, because the enclosing document already declared the contract. A fragment that declares a second type is two documents.",
                    cause: "A reader classifies a document from its first lines and reads everything after against that guess.",
                    decision:
                        "Fix the contract on the first line with a type, rather than leaving the reader to infer it from the directives below.",
                    failureMode:
                        "A reader cannot tell whether a document is a standing policy or a one-time task, walks a policy once and drops it, and the rules it carried apply to nothing.",
                    kind: "lesson",
                    principle: "A document declares what it is before it says what to do.",
                    problem:
                        "A document with no declared type has a contract nobody stated, so every reader supplies their own.",
                    validation:
                        "Cover everything below the declaration and ask what the document is for, what will walk it and how it will be used. A declaration that cannot answer all three is missing a type or an intent.",
                },
                {
                    kind: "text",
                    text: "The meta block settles four things before any node runs. The priority between sources, so a disagreement is decided before it arises, and the trust anchor, so a claim from an untrusted source is never promoted to evidence by being read. The jurisdiction, so what the document may touch and what it declares outside itself are stated rather than assumed, which is the boundary the honest gaps draws for a system, and a recursion limit, so a repair loop terminates. Choosing the type is choosing the contract, the reasoning model and the axis at once, and the verb makes the choice legible on the first line.",
                },
                {
                    kind: "text",
                    text: "The substrate and the spine are declared once and cited by every node. The substrate orders the nodes, as node design derives, and each node names its stage on it. The spine declares every transition: which node sequences to which, where a failed verification refutes back, and where the loop terminates. A node names its place on both and inherits the rest, which is why a document reads as one structure rather than ten documents. The document closes with its invariant records and a report, the verdict written as a representation a later checker can challenge, which is what a report, not a checkbox asks of a run.",
                },
                { code: SKELETON, kind: "code", language: PAG_LANGUAGE, title: "skeleton" },
                { code: TYPE_SHAPE, kind: "code", language: PAG_LANGUAGE, title: "the types" },
                { caption: "parts in order", kind: "mermaid", text: ORDER_DIAGRAM },
                { caption: "what a type fixes", kind: "mermaid", text: TYPE_DIAGRAM },
            ],
            title: "Declare, then instruct",
        },
    ],
    title: "Document structure",
};