module ui_x11

fn backend() {
    return {"init": init, "window": window, "label": label, "button": button, "input": input, "checkbox": checkbox, "textarea": textarea, "set_text": set_text, "get_text": get_text, "get_checked": get_checked, "set_checked": set_checked, "place": place, "remove": remove, "run": run}
}

fn button(_, win, title, x, y, w, h, onclick) {
    return _add(win, {"kind": "button", "text": title, "x": x, "y": y, "w": w, "h": h, "win": win, "onclick": onclick})
}

fn checkbox(_, win, title, x, y, w, h, onchange) {
    return _add(win, {"kind": "checkbox", "text": title, "checked": false, "x": x, "y": y, "w": w, "h": h, "win": win, "onchange": onchange})
}

fn get_checked(_, widget) {
    return widget["checked"]
}

fn get_text(_, widget) {
    if widget["kind"] == "window" {
        return widget["title"]
    }

    return widget["text"]
}

fn init(_) {
    return true
}

fn input(_, win, text, x, y, w, h, onsubmit) {
    return _add(win, {"kind": "input", "text": text, "x": x, "y": y, "w": w, "h": h, "win": win, "onsubmit": onsubmit})
}

fn label(_, win, text, x, y, w, h) {
    return _add(win, {"kind": "label", "text": text, "x": x, "y": y, "w": w, "h": h, "win": win})
}

fn place(u, widget, x, y, w, h) {
    widget["x"] = x
    widget["y"] = y
    widget["w"] = w
    widget["h"] = h
    return _redraw(u, widget["win"])
}

fn remove(u, widget) {
    win := widget["win"]
    kept := []
    views := win["views"]
    i := 0

    while i < len(views) {
        if !_same(views[i], widget) {
            kept = append(kept, views[i])
        }

        i = i + 1
    }

    win["views"] = kept

    if _same(win["focus"], widget) {
        win["focus"] = nil
    }

    return _redraw(u, win)
}

fn run(u) {
    x := u["x"]

    if x == nil {
        return error("ui: no window was created before run()")
    }

    events := chan(64)
    u["_x_stop"] = false
    task(fn() {
        while !u["_x_stop"] {
            ev := x11.wait_event(u["x"])
            // Bounded retry-push: the reader must never be stranded in a
            // blocking send after the loop has gone away.
            delivered := false

            while !delivered && !u["_x_stop"] {
                delivered = push(events, ev)

                if !delivered {
                    time.sleep(0.01)
                }
            }

            if is_error(ev) {
                return nil
            }
        }

        return nil
    })

    result := nil

    while u["running"] {
        _show_new_windows(u)
        // Fire due timers; the budget until the next one bounds the wait —
        // poll(ch, ms) is the scheduler's own timed receive, so a timer
        // deadline costs no waker tasks and wakes exactly on time.
        tick := u["tick"]
        budget := tick()
        ev := nil

        if budget == nil {
            ev = recv(events)
        } else {
            if budget < 1 {
                budget = 1
            }

            got := poll(events, budget)

            if !got[0] {
                // The budget elapsed: timers are due again.
                continue
            }

            ev = got[1]
        }

        if is_error(ev) {
            result = ev
            u["running"] = false
        } else {
            _handle(u, ev)
        }

        if !_any_window_open(u) {
            u["running"] = false
        }
    }

    // Tear down: closing the connection unblocks the reader, which sees the
    // dead socket and exits — nothing is left to keep the process alive.
    // The windows die with the connection, which real programs never see:
    // run() is their last act.
    u["_x_stop"] = true
    x11.close(u["x"])
    u["x"] = nil
    wins := u["windows"]
    i := 0

    while i < len(wins) {
        wins[i]["_closed"] = true
        i = i + 1
    }

    return result
}

fn set_checked(u, widget, v) {
    widget["checked"] = v == true
    return _redraw(u, widget["win"])
}

fn set_text(u, widget, text) {
    if widget["kind"] == "window" {
        widget["title"] = text
        return x11.set_title(u["x"], widget["wid"], text)
    }

    widget["text"] = text
    return _redraw(u, widget["win"])
}

fn textarea(_, win, content, x, y, w, h) {
    return _add(win, {"kind": "textarea", "text": content, "x": x, "y": y, "w": w, "h": h, "win": win})
}

fn window(u, title, w, h) {
    if u["x"] == nil {
        x := x11.connect()

        if is_error(x) {
            return x
        }

        u["x"] = x
    }

    x := u["x"]
    wid := x11.create_window(x, w, h, title)

    if is_error(wid) {
        return wid
    }

    gc := x11.create_gc(x, wid, _BLACK, _WHITE)

    if is_error(gc) {
        return gc
    }

    return {"kind": "window", "wid": wid, "gc": gc, "title": title, "w": w, "h": h, "views": [], "focus": nil, "_shown": false, "_closed": false, "onclose": nil}
}