Shikaku

// Shikaku has three constraints — all checked live inside model.isComplete:

// 1. Partition — the rectangles must cover the entire grid with no gaps or overlaps.

// 2. One clue per rectangle — each rectangle contains exactly one numbered clue cell.

// 3. Area must match — the rectangle's area (rowSpan × colSpan) must equal its clue.
//    A cell labelled "6" must be covered by a 1×6, 2×3, 3×2, or 6×1 rectangle.

// Read live puzzle state:
print(model.rects.count)   // rectangles placed so far
print(model.isSolved)      // true when all constraints are satisfied

@State private var model = ShikakuModel.example

var body: some View {
    // Pass a $Binding — every drag gesture is written back into model.rects
    ShikakuGameView(model: $model)
}

// Provide rows, columns, and a sparse clue dictionary (coord → required area).
let model = ShikakuModel(
    rows: 9,
    columns: 6,
    clues: [
        ShikakuCoord(row: 0, col: 1): 6,
        ShikakuCoord(row: 1, col: 2): 4,
        // …
    ]
)

// ── Configuration ─────────────────────────────────────────────────────
// model.rows             — number of rows in the grid
// model.columns          — number of columns in the grid
// model.clues            — [ShikakuCoord: Int] sparse map of coord → required rect area

// ── Live state (mutated during play) ──────────────────────────────────
// model.rects            — [ShikakuRect] the rectangles placed so far
// model.isSolved         — true once the puzzle is solved

// ── Computed ──────────────────────────────────────────────────────────
// model.isComplete       — true when the grid is fully and correctly partitioned
// model.rect(at:)        — returns the ShikakuRect covering a given coord, or nil

// ── Methods ────────────────────────────────────────────────────────────
// model.place(_ rect:)   — places a rectangle, removing any it overlaps first
// model.removeRect(at:)  — removes the rectangle covering a coordinate
// model.reset()          — clears all placed rectangles and resets isSolved

// Supply rows, columns, and a clue dictionary.
// The SDK validates nothing at init time; rule checking happens lazily via isComplete.
let model = ShikakuModel(
    rows: 9,
    columns: 6,
    clues: [
        ShikakuCoord(row: 0, col: 1): 6,
        ShikakuCoord(row: 1, col: 2): 4,
        ShikakuCoord(row: 2, col: 4): 6,
        ShikakuCoord(row: 4, col: 3): 6,
        ShikakuCoord(row: 3, col: 0): 6,
        ShikakuCoord(row: 5, col: 5): 6,
        ShikakuCoord(row: 7, col: 2): 6,
        ShikakuCoord(row: 6, col: 1): 6,
        ShikakuCoord(row: 7, col: 4): 4,
        ShikakuCoord(row: 8, col: 4): 4,
    ]
)

// Use ShikakuModel.example for the same ready-to-use 9×6 puzzle.
let example = ShikakuModel.example

// Drag across cells to draw a rectangle — releasing commits the placement.
// Tapping a covered cell removes its rectangle.

ShikakuGameView(model: $model)
    .onMove { rect in
        print("Placed \(rect.rowSpan)×\(rect.colSpan) rect at (\(rect.row),\(rect.col)) area=\(rect.area)")
    }

// ShikakuRect exposes:
// rect.row       — top-left row
// rect.col       — top-left column
// rect.rowSpan   — height in cells
// rect.colSpan   — width in cells
// rect.area      — rowSpan × colSpan
// rect.contains(_ coord:)      — true if coord falls inside this rect
// rect.isDisjoint(from: other) — true if the two rects do not overlap

// Violation highlighting is ON by default.
// Any rectangle that breaks a rule (wrong area, zero or multiple clues, out of bounds)
// receives isViolation: true on every cell it covers.
ShikakuGameView(model: $model)
    .showViolations(true)   // default — highlight rule-breaking rectangles

// Disable for a cleaner look (no real-time feedback)
ShikakuGameView(model: $model)
    .showViolations(false)

// Overlapping cells are highlighted in orange during an active drag.
// isOverlap: true is set on cells covered by both a placed rect and the drag preview —
// so the player sees exactly what will be overwritten before releasing.

// Hold the model in @State — the view writes every gesture back into model.rects
struct ContentView: View {
    @State private var model = ShikakuModel.example

    var body: some View {
        VStack {
            ShikakuGameView(model: $model)

            // Read live state directly from the binding's wrapped value
            if model.isSolved {
                Text("Puzzle solved!")
            }

            // Inspect placed rectangles any time
            Text("\(model.rects.count) rectangles placed")

            Button("Restart") { model.reset() }
        }
    }
}

ShikakuGameView(model: $model)
    .grid(spacing: 3, cell: MyShikakuCell.self)

struct MyShikakuCell: ShikakuCellProtocol {
    let row: Int
    let column: Int
    let state: ShikakuCellState

    init(row: Int, column: Int, state: ShikakuCellState) {
        self.row = row; self.column = column; self.state = state
    }

    var body: some View {
        ZStack {
            RoundedRectangle(cornerRadius: 6)
                .fill(background)
                .overlay(
                    RoundedRectangle(cornerRadius: 6)
                        .strokeBorder(state.isViolation ? Color.red : Color.clear, lineWidth: 2)
                )
            if state.isPreview {
                RoundedRectangle(cornerRadius: 6).fill(Color.accentColor.opacity(0.3))
            }
            if let clue = state.clue {
                Text("\(clue)")
                    .font(.system(size: 14, weight: .bold, design: .rounded))
                    .foregroundStyle(state.colorIndex != nil ? Color.white : Color(.label))
            }
        }
        .aspectRatio(1, contentMode: .fit)
        .animation(.easeInOut(duration: 0.12), value: state)
    }

    private var background: Color {
        if state.isOverlap { return Color.orange.opacity(0.5) }
        if let index = state.colorIndex {
            return palette[index % palette.count].opacity(0.6)
        }
        return Color(.systemGray5)
    }

    private let palette: [Color] = [.blue, .green, .orange, .purple, .pink, .teal]
}

// Register the custom cell
ShikakuGameView(model: $model)
    .grid(spacing: 3, cell: MyShikakuCell.self)

// Renders each grid cell — implement to customise cell appearance
public protocol ShikakuCellProtocol: View {
    init(row: Int, column: Int, state: ShikakuCellState)
}

// ShikakuCellState — passed to every cell on every render
public struct ShikakuCellState {
    let clue: Int?          // clue number at this cell, or nil
    let rect: ShikakuRect?  // rectangle covering this cell, or nil
    let isRectOrigin: Bool  // true if this is the top-left cell of its rectangle
    let isViolation: Bool   // true when the covering rectangle breaks a rule
    let isPreview: Bool     // true while a drag is active and this cell is inside the preview
    let isOverlap: Bool     // true when a drag preview would overwrite an existing rectangle
    let colorIndex: Int?    // stable palette index for the covering rectangle, or nil
}

// Hold an integer counter in @State — increment it to request a hint.
@State private var hintCount = 0

ShikakuGameView(model: $model)
    .hint(trigger: $hintCount)

// Each increment activates hint mode — all uncovered cells are highlighted with an orange tint.
// Tap any highlighted cell to reveal the solution rectangle that should cover it.
// Hint mode ends after one tap. Has no effect when no solution was provided or the puzzle is solved.
Button("Hint") { hintCount += 1 }

// Supply the solution when creating the model so hints know what to reveal:
let model = ShikakuModel(
    rows: 9,
    columns: 6,
    clues: [ ShikakuCoord(row: 0, col: 1): 6, /* … */ ],
    solution: [
        ShikakuRect(row: 0, col: 0, rowSpan: 3, colSpan: 2),
        // …
    ]
)

// ShikakuModel.example already includes a verified solution — hints work out of the box.
ShikakuGameView(model: $model)
    .hint(trigger: $hintCount)
    .onComplete {
        print("Solved — possibly with hints!")
    }

ShikakuGameView(model: $model)
    .grid(spacing: 2, cell: ShikakuCell.self)
    .showViolations(true)
    .onMove { rect in
        print("Placed \(rect.rowSpan)×\(rect.colSpan) at (\(rect.row),\(rect.col))")
    }
    .onComplete {
        print("Puzzle solved!")
    }