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

const SEPARATE_SAMPLE =
    "# <separate-a-unit> · ANALYZE -> FIND -> EXTRACT -> CREATE -> VERIFY\n# chosen because the request asks to split a unit that mixes two concerns\n\n# NODE 1 — ANALYZE THE UNIT       [epistemic · analysis · logic · yields: set]\n@genesis: difference\nCONTRACT:\n  input:     <unit>\n  transform: READ_RESOURCE <unit> INTO <source>; ANALYZE_CONTENT <source> AGAINST <responsibilities> INTO <concerns>\n  output:    <concerns>, each naming the lines that carry it\nHANDOFF GATE:\n  [check] <source> read from <unit> (evidence: the read returned content)\n  [check] <concerns> holds more than one entry (evidence: a count above one) over: <source> lines measured: <assigned> / <lines>\n  [check] every <concern> names its lines (evidence: no concern with an empty range)\n  result: pass -> NODE 2 | unread -> REPAIR (owner: NODE 1) | unknown -> BLOCKED\n\n# NODE 2 — FIND THE SEAMS         [epistemic · ontology · set-theory · yields: set]\n@genesis: existence\nCONTRACT:\n  input:     <concerns> from NODE 1\n  transform: SEARCH_CONTENT <source> FOR <boundaries between concerns> INTO <seams>\n  output:    <seams>\nHANDOFF GATE:\n  [check] every <seam> lies between two <concerns> (evidence: two concern ids per seam) over: <seams> measured: <between two> / <seams>\n  [check] no <seam> cuts a single statement (evidence: each seam on a statement boundary)\n  [check] <seams> is non-empty, or the unit is reported as one that does not split (evidence: a count, or the report)\n  result: pass -> NODE 3 | does not split -> TERMINATE | unknown -> BLOCKED\n\n# NODE 3 — EXTRACT THE CONCERN    [epistemic · reasoning · graph · yields: edge-list]\n@genesis: relation\nCONTRACT:\n  input:     <seams> from NODE 2\n  transform: EXTRACT_FACTS <concern> FROM <source> INTO <extracted>\n  preserves: every reference between <extracted> and the rest\n  output:    <extracted>, and every reference between it and the rest\nHANDOFF GATE:\n  [check] <extracted> carries every line of <concern> (evidence: the line ranges match) over: <concern> lines measured: <carried> / <lines>\n  [check] <source> minus <extracted> carries the rest (evidence: the two ranges partition the source)\n  [check] every reference between the two is named (evidence: an edge per reference)\n  result: pass -> NODE 4 | partition broken -> REPAIR (owner: NODE 2) | unknown -> BLOCKED\n\n# NODE 4 — CREATE THE NEW UNIT    [epistemic · formalisation · computation · yields: artifact]\n@genesis: structure\nCONTRACT:\n  input:     <extracted> from NODE 3\n  transform: COMPOSE_ARTIFACT <new-unit> FROM <extracted> USING <the shape units take here>; PERSIST_ARTIFACT <new-unit> TO <destination>\n  output:    <new-unit>\n  freshness: fingerprint(<extracted>) + fingerprint(this document)\nHANDOFF GATE:\n  [check] <new-unit> persisted (evidence: a read of <destination> returns it)\n  [check] <new-unit> declares what it imports from <unit> (evidence: the import list) over: references measured: <declared> / <references>\n  [check] <unit> declares what it imports from <new-unit> (evidence: the import list)\n  refuse: <destination> exists and was not read before PERSIST_ARTIFACT\n  result: pass -> NODE 5 | undeclared import -> REPAIR (owner: NODE 4) | unknown -> BLOCKED\n\n# NODE 5 — VERIFY THE SPLIT       [evaluative · verification · logic · yields: boolean]\n@genesis: constraint\nCONTRACT:\n  input:     <new-unit> from NODE 4\n  transform: EXECUTE_TOOL {toolchain.verify_command} INTO <verdict>; VALIDATE_ARTIFACT <verdict> AGAINST <green on one full run>\n  output:    <verdict>\nHANDOFF GATE:\n  [check] <verdict> green on one full run (evidence: the run's own output) over: the run's steps measured: <green> / <steps>\n  [check] no circular dependency between <unit> and <new-unit> (evidence: the import graph)\n  [check] every consumer of <unit> resolves (evidence: the typecheck)\n  refuse: a run that would mutate the tree before EXECUTE_TOOL\n  standing: moved-set <the files changed since NODE 4>\n  result: pass -> TERMINATE | red -> REPAIR (owner: NODE 3) | unknown -> BLOCKED";

const ENFORCE_SAMPLE =
    "# <author-an-enforcement> · ANALYZE -> CREATE -> LINK -> EXECUTE -> VERIFY\n# chosen because a rule held by attention needs a check that holds it\n\n# NODE 1 — ANALYZE THE SHAPE      [epistemic · analysis · logic · yields: set]\n@genesis: difference\nCONTRACT:\n  input:     <the violations seen so far>\n  transform: ANALYZE_CONTENT <the violations> AGAINST <the shape they share> INTO <shape>\n  output:    <shape>, with its one fix\nHANDOFF GATE:\n  [check] <shape> names a structure, never an instance (evidence: no vendor, symbol or path in it)\n  [check] every violation seen is an instance of <shape> (evidence: one match per violation) over: <the violations> measured: <matched> / <violations>\n  [check] one fix is stated for <shape> (evidence: the fix sentence)\n  result: pass -> NODE 2 | instance named -> REPAIR (owner: NODE 1) | unknown -> BLOCKED\n\n# NODE 2 — CREATE THE CHECK       [epistemic · formalisation · computation · yields: artifact]\n@genesis: structure\nCONTRACT:\n  input:     <shape> from NODE 1\n  transform: COMPOSE_ARTIFACT <check> FROM <shape> USING <the form checks take here>; PERSIST_ARTIFACT <check> TO {project.rule_home}\n  output:    <check>\n  freshness: fingerprint(<shape>) + fingerprint(this document)\nHANDOFF GATE:\n  [check] <check> persisted (evidence: a read of {project.rule_home} returns it)\n  [check] <check> reports <shape> and states its fix (evidence: its message)\n  [check] <check> names no vendor, symbol or path (evidence: a scan of its literals) over: its literals measured: <neutral> / <literals>\n  refuse: {project.rule_home} already holds a check of that name before PERSIST_ARTIFACT\n  result: pass -> NODE 3 | instance literal -> REPAIR (owner: NODE 2) | unknown -> BLOCKED\n\n# NODE 3 — LINK THE CHECK         [epistemic · reasoning · graph · yields: edge-list]\n@genesis: relation\nCONTRACT:\n  input:     <check> from NODE 2\n  transform: LINK <check> TO <the registry the gate reads>\n  output:    the registry entry\nHANDOFF GATE:\n  [check] <check> resolves from the registry (evidence: a lookup returns it)\n  [check] <check> is active (evidence: the entry)\n  [check] nothing else in the registry changed (evidence: a diff of the entries) over: registry entries measured: <unchanged> / <entries>\n  result: pass -> NODE 4 | unresolved -> REPAIR (owner: NODE 3) | unknown -> BLOCKED\n\n# NODE 4 — PROVE IT FIRES         [epistemic · formalisation · analysis · yields: procedure]\n@genesis: transformation\nCONTRACT:\n  input:     the registry entry from NODE 3\n  transform: PERSIST_ARTIFACT <a deliberate violation> TO <a probe>; EXECUTE_TOOL {toolchain.lint_command} INTO <report>; RESTORE <a probe>\n  output:    <report>\nHANDOFF GATE:\n  [check] <report> names <a probe> under <check> (evidence: the report line)\n  [check] <report> carries the expected message (evidence: the message text)\n  [check] <a probe> restored (evidence: a read returns the original) over: probes measured: <restored> / <planted>\n  refuse: <a probe> names a real file before PERSIST_ARTIFACT\n  result: pass -> NODE 5 | silent -> REPAIR (owner: NODE 2) | unknown -> BLOCKED\n\n# NODE 5 — VERIFY THE TREE        [evaluative · verification · logic · yields: boolean]\n@genesis: constraint\nCONTRACT:\n  input:     <report> from NODE 4\n  transform: EXECUTE_TOOL {toolchain.verify_command} INTO <verdict>; VALIDATE_ARTIFACT <verdict> AGAINST <green on one full run>\n  output:    <verdict>\nHANDOFF GATE:\n  [check] <verdict> green on one full run (evidence: the run's own output)\n  [check] every real occurrence of <shape> repaired in this change (evidence: the check reports none) over: occurrences measured: <repaired> / <occurrences>\n  [check] <check> caught each of them before the repair (evidence: the first run's report)\n  refuse: a run that would mutate the tree before EXECUTE_TOOL\n  standing: moved-set <the files changed since NODE 2>\n  result: pass -> TERMINATE | occurrence remains -> REPAIR (owner: NODE 1) | unknown -> BLOCKED";

const GATE_PROTOCOL_SAMPLE =
    "# <verification-gate> · ANALYZE -> VERIFY -> REPORT · appended to every plan\n\n# NODE N — VERIFY THE REASONING   [evaluative · verification · logic · yields: boolean]\n@genesis: constraint\nCONTRACT:\n  input:     every node above\n  transform: ANALYZE_CONTENT <every gate above> AGAINST <a check that is a judgement, lacks evidence or lacks a population> INTO <weak-gates>; VALIDATE_ARTIFACT every <claim> IN <the plan> AGAINST <the tree>; REPORT_RESULT <verdict> TO <the parties whose next work it creates>\n  output:    <verdict>, with every gate, its evidence, and what it reached\nHANDOFF GATE:\n  [check] <weak-gates> is empty (evidence: a count of zero) over: <every gate above> measured: <sound> / <gates>\n  [check] every <claim> supported by evidence, none by the absence of a contradiction (evidence: an evidence entry per claim)\n  [check] <verdict> names what the run reached before what it found (evidence: the report's first line)\n  standing: moved-set <the surfaces re-read since the plan began>\n  result: pass -> TERMINATE | weak gate -> REPAIR (owner: the earliest node whose gate is weak) | unknown -> BLOCKED";

const SHAPE_DIAGRAM =
    'flowchart TB\n    chain["A verb chain"]\n    nodes["Nodes · one per verb, tagged with the stage its verb derives"]\n    contract["A contract · reads the prior output, yields one record"]\n    gate["A gate · three to five checks over the node\'s output, each with its evidence and its set"]\n    empty["An empty result is a finding · never a skip"]\n    slot["A command or a location is a slot · the adapter resolves it"]\n    chain --> nodes --> contract --> gate\n    gate --> empty\n    nodes --> slot';

const TRANSFER_DIAGRAM =
    'flowchart LR\n    transfers["Transfers to any task of the shape · the chain, the tags, the contract and gate shape"]\n    bound["Bound per task · the nouns, the sources, the thresholds"]\n    instance["An instance"]\n    example["An example · someone else\'s nouns still inside"]\n    transfers --> instance\n    bound --> instance\n    transfers -. nouns not rebound .-> example';

export const ALGORITHM_SECTION: Section = {
    icon: ALGORITHM_SECTION_ICON,
    id: ALGORITHM_SECTION_ID,
    intro: "An algorithm is a protocol instantiated: the chain expanded into nodes, each headed by its layer, axis, math type and yields and tagged with its genesis stage, each contracted to the prior node's output and closed by an evidence-bearing gate, and every placeholder bound to the task's own nouns. Three instances follow, <cite>separate a unit</cite>, <cite>author an enforcement</cite> and <cite>verification gate</cite>, and the diagrams say what every instance carries beyond its chain, <cite>beyond the chain</cite>, and what transfers between them and what is bound per task, <cite>transfers or bound</cite>.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "Write the chain above the nodes, with the reason it was chosen, so a reader sees the protocol before the instance. Expand one node per verb, tag it with the stage the verb derives, and bind each placeholder to a noun from the task so no placeholder survives into the document. Give each node a contract whose input names the prior output, and close it on three to five checks that name its output, the evidence that settles each and the set at least one ranged over. Route a failure to the earliest node that can supply the missing evidence and an unknown to blocked, refuse before every write, make an empty result a finding rather than a silent skip, and name every command and location as a slot the adapter resolves.",
                    boundary:
                        "A node with two decisions is two nodes, and the examples are not a licence to collapse them.",
                    cause: "The chain is the protocol's contract and the gates are how the contract is checked, so the two transfer together and the nouns do not.",
                    decision:
                        "Bind the task's nouns into the protocol's shape, rather than edit an example until it fits.",
                    failureMode:
                        "A seam search returns nothing, the node is skipped without an entry, the extraction runs over an empty set, and the count that would have exposed the gap is taken over the wrong population.",
                    kind: "lesson",
                    principle:
                        "An algorithm is a protocol with its chain expanded, its nodes tagged and its steps gated.",
                    problem: "An algorithm copied from an example keeps the example's nouns and loses the task's.",
                    validation:
                        "Find a placeholder that survived into the document, a node whose stage disagrees with its verb, a contract whose input names nothing from its predecessor, or a gate whose count is taken over a set smaller than the one it claims. Any of the four is an instance that was copied rather than bound.",
                },
                {
                    kind: "text",
                    text: "In the first instance two checks carry the honesty. An empty seam set is a unit that does not split and is reported as such, because a green over an empty population measures nothing, and the population beside the verdict is what makes that visible. The repair owner on the extraction gate is the seam node, because a bad extraction is usually a bad seam.",
                },
                {
                    kind: "text",
                    text: "The second instance is the shape every rule held by attention takes before it is trusted. The analysis names a shape rather than an instance, because a check that names an instance dies on the next case. The check is proven to fire the way the check comes first describes, and that failure routes back to the node that composed the check, not to the probe; the probe's own write is refused where it would land on a real file.",
                },
                {
                    kind: "text",
                    text: "The third instance is appended to every plan rather than chosen; its gate is the evidence gate of from intent to structure, applied to the plan's own reasoning, and its standing line names what moved beneath the plan while it was checked.",
                },
                { code: SEPARATE_SAMPLE, kind: "code", language: PAG_LANGUAGE, title: "separate a unit" },
                { code: ENFORCE_SAMPLE, kind: "code", language: PAG_LANGUAGE, title: "author an enforcement" },
                { code: GATE_PROTOCOL_SAMPLE, kind: "code", language: PAG_LANGUAGE, title: "verification gate" },
                { caption: "beyond the chain", kind: "mermaid", text: SHAPE_DIAGRAM },
                { caption: "transfers or bound", kind: "mermaid", text: TRANSFER_DIAGRAM },
            ],
            title: "Three instances",
        },
    ],
    title: "Algorithm examples",
};