//! Events which are defined by the library. They might be extended by user
//! events.
const std = @import("std");
const terminal = @import("terminal.zig");

// Application events which contain information about default application
// parameter. Either `none` or `err`, where `none` represents no event with no
// message, while `err` represents an error which is propagated. `Widget`s or
// `Layout`s may react to the event but should continue throwing the message up
// to the application event loop.
pub const ApplicationEvent = union(enum) {
    none,
    err: []const u8,
};

// System events which contain information about events triggered from outside
// of the application which impact the application. E.g. the terminal window
// size has changed, etc.
pub const SystemEvent = union(enum) {
    resize: terminal.Size,
};

pub const BuiltinEvent = MergeTaggedUnions(SystemEvent, ApplicationEvent);

pub fn MergeTaggedUnions(comptime A: type, comptime B: type) type {
    if (!isTaggedUnion(A) or !isTaggedUnion(B)) {
        @compileError("Both types for merging tagged unions need to be of type `union(enum)`.");
    }
    const a_fields = @typeInfo(A).Union.fields;
    const a_fields_tag = @typeInfo(A).Union.tag_type.?;
    const a_enum_fields = @typeInfo(a_fields_tag).Enum.fields;
    const b_fields = @typeInfo(B).Union.fields;
    const b_fields_tag = @typeInfo(B).Union.tag_type.?;
    const b_enum_fields = @typeInfo(b_fields_tag).Enum.fields;
    var fields: [a_fields.len + b_fields.len]std.builtin.Type.UnionField = undefined;
    var enum_fields: [a_fields.len + b_fields.len]std.builtin.Type.EnumField = undefined;
    var i: usize = 0;
    for (a_fields, a_enum_fields) |field, enum_field| {
        fields[i] = field;
        var enum_f = enum_field;
        enum_f.value = i;
        enum_fields[i] = enum_f;
        i += 1;
    }
    for (b_fields, b_enum_fields) |field, enum_field| {
        fields[i] = field;
        var enum_f = enum_field;
        enum_f.value = i;
        enum_fields[i] = enum_f;
        i += 1;
    }

    const log2_i = @bitSizeOf(@TypeOf(i)) - @clz(i);

    const EventType = @Type(.{ .Int = .{
        .signedness = .unsigned,
        .bits = log2_i,
    } });

    const Event = @Type(.{ .Enum = .{
        .tag_type = EventType,
        .fields = enum_fields[0..],
        .decls = &.{},
        .is_exhaustive = true,
    } });

    return @Type(.{ .Union = .{
        .layout = .auto,
        .tag_type = Event,
        .fields = fields[0..],
        .decls = &.{},
    } });
}

// Determine at `comptime` wether the provided type `E` is an `union(enum)`.
pub fn isTaggedUnion(comptime E: type) bool {
    switch (@typeInfo(E)) {
        .Union => |u| {
            if (u.tag_type) |_| {} else {
                return false;
            }
        },
        else => return false,
    }
    return true;
}