const std = @import("std");
const Allocator = std.mem.Allocator;

const flecs = @import("./main.zig");
const c = flecs.c;
const err = @import("./error.zig");
const util = @import("./util.zig");

const Lookup = @import("./main.zig").Lookup;
const Entity = @import("./entity.zig").Entity;
const EntityError = @import("./entity.zig").EntityError;
const Iter = @import("./iter.zig").Iter;
const Path = @import("./path.zig").Path;

pub fn World(comptime ctx: anytype) type {
    return struct {
        raw: *c.ecs_world_t,

        const Self = @This();

        pub fn init() !*Self {
            std.debug.assert(flecs.is_initialized);
            var result = try flecs.allocator.create(Self);
            result.raw = c.ecs_init().?;
            return result;
        }

        pub fn initWithArgs(args: [][*:0]const u8) !*Self {
            std.debug.assert(flecs.is_initialized);
            var result = try flecs.allocator.create(Self);
            result.raw = c.ecs_init_w_args(args.len, args.ptr).?;
            return result;
        }

        pub fn initMinimal() !*Self {
            std.debug.assert(flecs.is_initialized);
            var result = try flecs.allocator.create(Self);
            result.raw = c.ecs_mini().?;
            return result;
        }

        pub fn deinit(self: *Self) void {
            _ = c.ecs_fini(self.raw);
            flecs.allocator.destroy(self);
        }

        pub fn progress(self: *Self, delta_time: f32) bool {
            return c.ecs_progress(self.raw, delta_time);
        }

        pub fn quit(self: *Self) void {
            c.ecs_quit(self.raw);
        }

        /// Returns an `Entity` for the specified `ecs_entity_t` value, or an
        /// error if the entity is invalid or not alive in this `World`.
        pub fn lookupAlive(self: *Self, id: c.ecs_entity_t) !Entity(ctx) {
            const result = Entity(ctx).fromRaw(self, id);
            try result.ensureAlive();
            return result;
        }

        // TODO: Reconsider whether lookup functions should return errors or just optionals.
        // TODO: Reconsider whether "Entity" should always be in backticks in our doc comments.
        // TODO: We really need tests for this function.
        /// Returns the `Entity` at the specified path, or an error if the
        /// entity does not exist. If the path is not absolute, the operation
        /// will use the current scope, or the world root.
        pub fn lookupByPath(self: *Self, path: Path) !Entity(ctx) {
            var parent = if (path.absolute) 0 else c.ecs_get_scope(self.raw);
            var current: c.ecs_entity_t = undefined;
            for (path.parts) |part| {
                current = switch (part) {
                    .id => |i| c.ecs_get_alive(self.raw, i),
                    .name => |n| c.ecs_lookup_child(self.raw, parent, n.ptr),
                };
                if (current == 0) return error.EntityNotFound;
                // If a part is looked up by ID, parent must match.
                // If a part is looked up by name, this check isn't necessary.
                if (part == .id and parent != c.ecs_get_parent(self.raw, current)) return error.ParentMismatch;
                parent = current;
            }
            return Entity(ctx).fromRaw(self, current);
        }

        /// Returns the component `Entity` registered for the specified
        /// type `T`, or an error if an association has not been made.
        pub fn lookupByType(self: *Self, comptime T: type) !Entity(ctx) {
            return lookupAlive(self, Lookup(ctx, T).id);
        }

        /// Creates or modifies an `Entity` in this `World`.
        /// See `Entity.init(...)` for more information.
        pub fn entity(self: *Self, config: Entity(ctx).Config, add: anytype) !Entity(ctx) {
            return Entity(ctx).init(self, config, add);
        }

        pub fn tag(self: *Self, comptime T: type) !Entity(ctx) {
            if (@sizeOf(T) > 0) @compileError("'" ++ @typeName(T) ++ "' must be a zero-sized type");
            const name = util.simpleTypeName(T);
            const result = try self.entity(.{ .name = name, .symbol = name }, .{});
            Lookup(ctx, T).id = result.raw;
            return result;
        }

        pub fn component(self: *Self, comptime T: type) !Entity(ctx) {
            if (@sizeOf(T) == 0) @compileError("'" ++ @typeName(T) ++ "' must not be a zero-sized type");
            const name = util.simpleTypeName(T);
            const entity2 = try self.entity(.{ .name = name, .symbol = name, .use_low_id = true }, .{});

            const desc = std.mem.zeroInit(c.ecs_component_desc_t, .{
                .entity = entity2.raw,
                .type = .{ .size = @sizeOf(T), .alignment = @alignOf(T) },
            });

            var result = c.ecs_component_init(self.raw, &desc);
            if (result == 0) return err.getLastErrorOrUnknown();
            Lookup(ctx, T).id = result;
            return Entity(ctx).fromRaw(self, result);
        }

        /// Registers a singleton component of type `T` with the specified value.
        ///
        /// A singleton is a component which has itself added to its entity.
        /// This allows looking up a value of `T` using its own type. Only one
        /// singleton of each type can exist per world, but other entities may
        /// still have this component added to them.
        ///
        /// Use `get()` and `set()` to get and set the value of this singleton.
        ///
        /// Returns the created component entity.
        pub fn singleton(self: *Self, comptime T: type, value: T) !Entity(ctx) {
            const single = try component(self, T);
            single.set(T, value);
            return single;
        }

        /// Gets the value of the singleton component with type `T`.
        ///
        /// Returns `error.IsNotAlive` if the entity is missing.
        /// Returns `error.ComponentMissing` if the component is missing.
        /// Both of these may occur from not calling `singleton()` first.
        pub fn get(self: *Self, comptime T: type) !T {
            const e = try self.lookupByType(T);
            return e.get(T) orelse error.ComponentMissing;
        }

        /// Sets the value of the singleton component with type `T`.
        ///
        /// Returns `error.IsNotAlive` if the entity is missing.
        /// This may occur from not calling `singleton()` first.
        pub fn set(self: *Self, comptime T: type, value: T) !void {
            const e = try self.lookupByType(T);
            e.set(T, value);
        }

        pub fn system(
            self: *Self,
            name: [:0]const u8,
            callback: SystemCallback,
            phase: anytype,
            expr: [:0]const u8,
        ) !Entity(ctx) {
            const phase2 = util.anyToEntity(ctx, phase);
            const entity2 = try if (phase2 != 0)
                self.entity(.{ .name = name }, .{ .{ c.EcsDependsOn, phase2 }, phase2 })
            else
                self.entity(.{ .name = name }, .{});

            var context = try SystemCallbackContext.init(self, callback);
            var desc = std.mem.zeroInit(c.ecs_system_desc_t, .{
                .entity = entity2.raw,
                .callback = &SystemCallbackContext.invoke,
                .binding_ctx = context,
                .binding_ctx_free = &SystemCallbackContext.free,
            });
            desc.query.filter.expr = expr;

            const result = c.ecs_system_init(self.raw, &desc);
            if (result == 0) return err.getLastErrorOrUnknown();
            return Entity(ctx).fromRaw(self, result);
        }

        const SystemCallback = *const fn (Iter(ctx)) void;
        const SystemCallbackContext = struct {
            world: *Self,
            func: SystemCallback,

            pub fn init(world: *Self, callback: SystemCallback) !*SystemCallbackContext {
                var result = try flecs.allocator.create(SystemCallbackContext);
                result.world = world;
                result.func = callback;
                return result;
            }

            fn free(context: ?*anyopaque) callconv(.C) void {
                const self: *SystemCallbackContext = @alignCast(@ptrCast(context));
                flecs.allocator.destroy(self);
            }

            // FIXME: Dependency loop.
            // Currently needs manual changing of the generated C code.
            // fn invoke(it: ?*c.ecs_iter_t) callconv(.C) void {
            fn invoke(it2: *anyopaque) callconv(.C) void {
                const it: ?*c.ecs_iter_t = @alignCast(@ptrCast(it2));
                const context: *SystemCallbackContext = @alignCast(@ptrCast(it.?.binding_ctx));
                var iter = Iter(ctx).fromRawPtr(context.world, it.?);
                context.func(iter);
            }
        };

        /// Creates a term iterator which allows querying for all entities
        /// that have a specific `Id`. This function supports wildcards.
        pub fn term(self: *Self, id: anytype) TermIterator {
            const id_ = util.anyToId(ctx, id);
            var term_ = std.mem.zeroInit(c.ecs_term_t, .{ .id = id_ });
            const iter = c.ecs_term_iter(self.raw, &term_);
            return .{ .world = self, .iter = iter };
        }

        // TODO: Move this logic to `Iter`, add `TermIter` type?
        // TODO: Rename `Iter` to `Iterator`?
        pub const TermIterator = struct {
            world: *World(ctx),
            iter: c.ecs_iter_t,
            index: i32 = 0,

            pub fn next(self: *TermIterator) ?Entity(ctx) {
                if (self.index >= self.iter.count)
                    if (!c.ecs_term_next(&self.iter))
                        return null;

                const result = self.iter.entities[@intCast(self.index)];
                self.index += 1;
                return Entity(ctx).fromRaw(self.world, result);
            }

            // TODO: Check where else in the codebase it would make sense to have `deinit` take a pointer?
            pub fn deinit(self: *TermIterator) void {
                // Finalize the iterator if it hasn't run to completion.
                if ((self.iter.flags & c.EcsIterIsValid) != 0)
                    c.ecs_iter_fini(&self.iter);
                self.* = undefined;
            }
        };

        /// Gets the current scope of this `World`. See also: `setScope()`.
        pub fn getScope(self: *Self) ?Entity(ctx) {
            const result = c.ecs_get_scope(self.raw);
            return if (result != 0) Entity(ctx).fromRaw(self, result) else null;
        }

        /// Sets the current scope of this `World` to the specified entity.
        ///
        /// Setting a scope causes certain operations to be made in relation
        /// to the scope entity, rather than the world root. Passing `null`
        /// causes the scope to be set to the world root.
        ///
        /// Returns the previously set scope, if any. It's recommended to set
        /// the scope back to the previous value after you're done operating
        /// in the desired scope.
        pub fn setScope(self: *Self, value: anytype) ?Entity(ctx) {
            const result = c.ecs_set_scope(self.raw, util.anyToEntity(ctx, value));
            return if (result != 0) Entity(ctx).fromRaw(self, result) else null;
        }
    };
}