const std = @import("std");
const builtin = @import("builtin");

const vaxis = @import("vaxis");
const xev = @import("xev");
const Cell = vaxis.Cell;

const networking = @import("./networking.zig");
const rotctl = @import("./rotctl.zig");

const log = std.log.scoped(.rotint);

pub const panic = vaxis.panic_handler;

pub const std_options: std.Options = .{
    .log_level = if (builtin.mode == .Debug) .debug else .err,
};

// these are all in degrees
pub const AzEl = struct { az: f64, el: f64 };

pub const RotInt = struct {
    allocator: std.mem.Allocator,
    // TODO: associate timestamps with this somehow
    offsets: AzEl = .{ .az = 0, .el = 0 },
    requested_posture: AzEl = .{ .az = 0, .el = 0 },
    current_posture: AzEl = .{ .az = 0, .el = 0 },
    flipflop: bool = false,
    state: State = .initial,

    termbuffer: std.io.BufferedWriter(4096, std.io.AnyWriter),
    vx: *vaxis.Vaxis,
    loop: *xev.Loop,

    parser: rotctl.RotCtl = .{},
    last_command: rotctl.RotCommand = undefined,
    server: networking.Server = .{},
    rotator: networking.Client = .{},
    poller: xev.Timer,
    poll_completion: xev.Completion = undefined,

    const poll_interval: u64 = 1000;

    pub const State = enum {
        initial,
        rotator_connected,
        rotator_ready,
        server_connected,
    };

    pub fn initInPlace(self: *RotInt) !void {
        self.server.rotint = self;
        self.rotator.rotint = self;

        const connect_addr = try std.net.Address.parseIp("127.0.0.1", 4533);
        try self.rotator.connect(self.loop, connect_addr);
    }

    pub fn stateEvent(self: *RotInt, event: State) void {
        switch (event) {
            .initial => {},
            .rotator_connected => if (self.state == .initial) {
                self.warn("rotator connected", .{});
                self.sendRotatorCommand(.get_position);
                self.state = .rotator_connected;
            },
            .rotator_ready => if (self.state == .rotator_connected) {
                self.warn("rotator ready", .{});
                const listen_addr = std.net.Address.parseIp("127.0.0.1", 42069) catch {
                    self.warn("bogus listen address", .{});
                    return;
                };
                self.server.listen(self.loop, listen_addr) catch {
                    self.warn("listen problem", .{});
                    return;
                };
                // demangle here to avoid causing initial moves
                self.requested_posture = .{
                    .az = self.current_posture.az - self.offsets.az,
                    .el = self.current_posture.el - self.offsets.el,
                };
                self.state = .rotator_ready;
            },
            .server_connected => if (self.state == .rotator_ready) {
                self.warn("server listening", .{});
                self.state = .server_connected;
            },
        }
    }

    fn poll(
        self_: ?*RotInt,
        _: *xev.Loop,
        _: *xev.Completion,
        result: xev.Timer.RunError!void,
    ) xev.CallbackAction {
        const self = self_.?;
        result catch {
            self.warn("timer error???", .{});
            return .disarm;
        };

        if (self.flipflop) {
            const mangled: AzEl = .{
                .az = self.requested_posture.az + self.offsets.az,
                .el = self.requested_posture.el + self.offsets.el,
            };
            self.sendRotatorCommand(.{ .set_position = mangled });
        } else {
            self.sendRotatorCommand(.get_position);
        }
        self.flipflop = !self.flipflop;

        return .disarm;
    }

    fn sendRotatorCommand(self: *RotInt, command: rotctl.RotCommand) void {
        self.last_command = command;
        self.rotator.sendCommand(self.loop, command);
    }

    pub fn handleRotatorReply(self: *RotInt, res: []const u8) void {
        const reply = self.parser.parseReplyFor(self.last_command, res) catch |err| switch (err) {
            error.Incomplete => return,
            error.InvalidParameter => {
                return;
            },
        };

        switch (reply) {
            .okay => {},
            .get_position => |pos| {
                self.current_posture = pos;
                if (self.state == .rotator_connected) self.stateEvent(.rotator_ready);
                self.draw() catch {};
            },
            .status => |code| if (code != .okay)
                self.warn("rotctl error {s}", .{@tagName(code)}),
        }
        self.poller.run(self.loop, &self.poll_completion, poll_interval, RotInt, self, poll);
    }

    pub fn warn(_: *RotInt, comptime fmt: []const u8, args: anytype) void {
        log.warn(fmt, args);
    }

    pub fn handleControlRequest(self: *RotInt, req: []const u8) void {
        const command = self.parser.parseCommand(req) catch |err| switch (err) {
            error.Incomplete => return,
            error.NotSupported => {
                self.server.respond(self.loop, .{ .status = .not_supported });
                return;
            },
            error.InvalidParameter => {
                self.server.respond(self.loop, .{ .status = .invalid_parameter });
                return;
            },
        };

        switch (command) {
            .get_position => self.server.respond(self.loop, .{ .get_position = self.current_posture }),

            .set_position => |pos| {
                self.requested_posture = pos;
                self.server.respond(self.loop, .okay);
                self.draw() catch {};
            },

            .stop => self.server.respond(self.loop, .okay),
            .park => self.server.respond(self.loop, .okay),
            .quit => {
                self.server.respond(self.loop, .okay);
                self.server.should_disconnect = true;
            },
        }
    }

    fn draw(self: *RotInt) !void {
        const win = self.vx.window();
        win.clear();

        var lines: [3][128]u8 = undefined;
        const offsets: vaxis.Segment = .{ .text = try std.fmt.bufPrint(
            lines[0][0..],
            "Offsets:   Az: {d: >6.1}, El: {d: >6.1}",
            .{ self.offsets.az, self.offsets.el },
        ) };
        const requested: vaxis.Segment = .{ .text = try std.fmt.bufPrint(
            lines[1][0..],
            "Requested: Az: {d: >6.1}, El: {d: >6.1}",
            .{ self.requested_posture.az, self.requested_posture.el },
        ) };
        const current: vaxis.Segment = .{ .text = try std.fmt.bufPrint(
            lines[2][0..],
            "Current:   Az: {d: >6.1}, El: {d: >6.1}",
            .{ self.current_posture.az, self.current_posture.el },
        ) };

        const center = vaxis.widgets.alignment.center(win, offsets.text.len, 1);
        _ = try center.printSegment(offsets, .{});
        const center_up = win.initChild(center.x_off, center.y_off + 1, .{ .limit = requested.text.len }, .{ .limit = 1 });
        _ = try center_up.printSegment(requested, .{});
        const center_down = win.initChild(center.x_off, center.y_off - 1, .{ .limit = current.text.len }, .{ .limit = 1 });
        _ = try center_down.printSegment(current, .{});

        try self.vx.render(self.termbuffer.writer().any());
        try self.termbuffer.flush();
    }
};

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();

    const alloc = gpa.allocator();

    var tty = try vaxis.Tty.init();
    defer tty.deinit();

    var vx = try vaxis.init(alloc, .{});
    defer vx.deinit(alloc, tty.anyWriter());

    var pool = xev.ThreadPool.init(.{});
    var loop = try xev.Loop.init(.{
        .thread_pool = &pool,
    });
    defer loop.deinit();

    var app: RotInt = .{
        .allocator = alloc,
        .termbuffer = tty.bufferedWriter(),
        .vx = &vx,
        .loop = &loop,
        .poller = try xev.Timer.init(),
    };
    try app.initInPlace();

    var vx_loop: vaxis.xev.TtyWatcher(RotInt) = undefined;
    try vx_loop.init(&tty, &vx, &loop, &app, eventCallback);

    try vx.enterAltScreen(tty.anyWriter());
    try vx.queryTerminalSend(tty.anyWriter());
    // Window size appears to be left uninitialized unless we manually set it here. This
    // seems sketchy to me (tty fd should be nonblocking for the event loop)
    const size = try vaxis.Tty.getWinsize(tty.fd);
    vx.resize(alloc, tty.anyWriter(), size) catch @panic("TODO");

    try loop.run(.until_done);
}

fn eventCallback(
    self_: ?*RotInt,
    loop: *xev.Loop,
    watcher: *vaxis.xev.TtyWatcher(RotInt),
    event: vaxis.xev.Event,
) xev.CallbackAction {
    const self = self_.?;
    switch (event) {
        .key_press => |key| keyp: {
            var mods = key.mods;
            mods.caps_lock = false;
            mods.num_lock = false;
            const scale: f64 = if (std.meta.eql(mods, .{ .shift = true })) 1 else 10;

            const delta: AzEl = switch (key.codepoint) {
                vaxis.Key.left, vaxis.Key.kp_left => .{ .az = -0.1 * scale, .el = 0 },
                vaxis.Key.right, vaxis.Key.kp_right => .{ .az = 0.1 * scale, .el = 0 },
                vaxis.Key.up, vaxis.Key.kp_up => .{ .az = 0, .el = 0.1 * scale },
                vaxis.Key.down, vaxis.Key.kp_down => .{ .az = 0 * scale, .el = -0.1 * scale },
                'l' => {
                    if (std.meta.eql(mods, .{ .ctrl = true }))
                        self.vx.queueRefresh();
                    break :keyp;
                },
                'c' => {
                    if (std.meta.eql(mods, .{ .ctrl = true })) {
                        loop.stop();
                        return .disarm;
                    }
                    break :keyp;
                },
                'q' => {
                    if (std.meta.eql(mods, .{})) {
                        loop.stop();
                        return .disarm;
                    }
                    break :keyp;
                },
                else => break :keyp,
            };

            self.offsets.az += delta.az;
            self.offsets.el += delta.el;
            self.draw() catch {
                self.warn("draw failure", .{});
            };
        },
        .winsize => |ws| {
            watcher.vx.resize(self.allocator, watcher.tty.anyWriter(), ws) catch
                return .disarm;
        },
        else => {},
    }
    return .rearm;
}

fn timerCallback(
    ud: ?*RotInt,
    loop: *xev.Loop,
    completion: *xev.Completion,
    err: xev.Timer.RunError!void,
) xev.CallbackAction {
    _ = err catch @panic("timer error");

    var app = ud orelse return .disarm;
    app.draw() catch @panic("couldn't draw");

    const timer = xev.Timer.init() catch unreachable;
    timer.run(loop, completion, 8, RotInt, app, timerCallback);
    return .disarm;
}