/**
 * moveLine.js: move-tree → render items
 *
 * Walks the branching move tree the same way the PGN exporter does (see
 * pgnFormat.js's childrenOf/collectMainPath) and produces a flat list of
 * render items for the move-list panel: 'row' items for the main line's
 * Rank/White/Black grid, and 'variation' items for parenthesised
 * alternatives, each carrying enough to expand into its own paragraph
 * without re-walking the tree.
 */

import { ROOT_ID, childrenOf, collectMainPath } from './pgnFormat.js';

// Builds the main line as row items: one full move per row. A move with
// alternatives gets a 'variation' item right after it instead of packed
// into its own cell - since a variation spans the full row width, the
// next row after it always starts fresh.
export function buildMainLine(nodes, rootChildren, nodeIds, parentId, whiteToMove, moveNum, currentId) {
    const items = [];
    let row = { kind: 'row', num: moveNum, white: whiteToMove ? null : { placeholder: true }, black: null };
    items.push(row);

    nodeIds.forEach((id, i) => {
        const node = nodes[id];
        const parentForThis = i === 0 ? parentId : nodeIds[i - 1];
        const kids          = childrenOf(nodes, rootChildren, parentForThis);
        const hasVariation  = kids.length > 1;

        if (whiteToMove) row.white = { node, isCurrent: node.id === currentId };
        else row.black = { node, isCurrent: node.id === currentId };

        const wasWhite    = whiteToMove;
        const thisMoveNum = moveNum;
        if (!whiteToMove) moveNum++;
        whiteToMove = !whiteToMove;

        if (hasVariation) {
            for (let v = 1; v < kids.length; v++) {
                const varPath = collectMainPath(nodes, kids[v]);
                items.push({ kind: 'variation', nodeIds: varPath, whiteToMove: wasWhite, moveNum: thisMoveNum, depth: 1 });
            }
        }

        if (i !== nodeIds.length - 1) {
            if (wasWhite && !hasVariation) {
                // continues into this row's still-empty black cell
            } else {
                row = { kind: 'row', num: moveNum, white: whiteToMove ? null : { placeholder: true }, black: null };
                items.push(row);
            }
        }
    });
    return items;
}

// Builds one variation's body as a sequence of paragraphs (chip lists):
// a move within it that itself has alternatives interrupts the paragraph:
// the nested variation(s) become their own, more deeply indented items,
// and this variation's remaining moves continue in a fresh paragraph at
// the same depth.
export function buildVariation(nodes, rootChildren, nodeIds, whiteToMove, moveNum, currentId, depth) {
    const items = [];
    let para = { kind: 'para', depth, chips: [] };
    items.push(para);

    nodeIds.forEach((id, i) => {
        const node = nodes[id];
        // i === 0 is the move that spawned this variation body - its
        // siblings were already enumerated by the caller as separate
        // variation items, so this doesn't re-derive them here.
        const parentForThis = i === 0 ? null : nodeIds[i - 1];
        const kids          = parentForThis !== null ? childrenOf(nodes, rootChildren, parentForThis) : null;
        const hasVariation  = !!(kids && kids.length > 1);

        if (whiteToMove || i === 0) {
            para.chips.push({ kind: 'num', text: moveNum + (whiteToMove ? '.' : '…') });
        }
        para.chips.push({ kind: 'move', node, isCurrent: node.id === currentId });

        const wasWhite    = whiteToMove;
        const thisMoveNum = moveNum;
        if (!whiteToMove) moveNum++;
        whiteToMove = !whiteToMove;

        if (hasVariation) {
            for (let v = 1; v < kids.length; v++) {
                const varPath = collectMainPath(nodes, kids[v]);
                items.push({ kind: 'variation', nodeIds: varPath, whiteToMove: wasWhite, moveNum: thisMoveNum, depth: depth + 1 });
            }
            if (i !== nodeIds.length - 1) {
                para = { kind: 'para', depth, chips: [] };
                items.push(para);
            }
        }
    });
    return items;
}

export function buildMoveListItems(nodes, rootChildren, currentId, turn, fullmove) {
    if (!rootChildren || rootChildren.length === 0) return [];
    const mainPath = collectMainPath(nodes, rootChildren[0]);
    return buildMainLine(nodes, rootChildren, mainPath, ROOT_ID, turn === 'w', fullmove, currentId);
}