const std = @import("std");
const ast = @import("ast.zig");
const Scope = ast.Scope;
const common = @import("common.zig");
const Str = common.Str;

predefinedTypes: [NumPredefinedTypes]*const ast.Data,
predefinedClasses: [NumPredefinedClasses]*ast.Class,
intTypeTemp: ast.Type,

const Self = @This();

pub const PremadeType = enum {
    Unit,
    Bool,

    I8,
    U8,
    I32,
    U32,
    I64,
    U64,
    Size,

    F32,
    F64,

    ConstStr,
    // StrView,
    Char,
    Ptr,
    Array,
    StrConcat,
    ListSpread,
    Ordering,
    Maybe,

    Tuple2,
    Tuple3,
    Tuple4,
};
pub const NumPredefinedTypes = NumEnums(PremadeType);

// later should be defined in prelude?
pub fn defined(self: *const Self, premade: PremadeType) *const ast.Data {
    return self.predefinedTypes[@intFromEnum(premade)];
}

pub fn fromData(self: *const Self, data: *const ast.Data) ?PremadeType {
    for (self.predefinedTypes, 0..) |pd, i| {
        if (pd == data) {
            return @as(PremadeType, @enumFromInt(i));
        }
    }

    return null;
}

// I don't know how to easily extract field names from an enum value.
pub const PremadeTypeName = TypeNameArray(PremadeType);

pub const PremadeClass = enum {
    Eq,
    Ord,

    Addition,
    Subtraction,
    Multiplication,
    Division,
    Negation,

    FromIntegral,
    FromChar,
    FromString,
    ListDecon,
    ListLike,
    Indexable,

    // needed for `for .. in`
    Iter,
    IntoIter,
    // MapList,
};

pub const NumPredefinedClasses = NumEnums(PremadeClass);

pub const PremadeClassName = TypeNameArray(PremadeClass);

pub fn definedClass(self: *const Self, premade: PremadeClass) *ast.Class {
    return self.predefinedClasses[@intFromEnum(premade)];
}

// generic stuff
fn NumEnums(t: type) comptime_int {
    return @typeInfo(t).Enum.fields.len;
}

fn TypeNameArray(t: type) std.EnumArray(t, Str) {
    var typenames = std.EnumArray(t, Str).initUndefined();
    for (@typeInfo(t).Enum.fields) |enumField| {
        typenames.set(@enumFromInt(enumField.value), enumField.name);
    }
    return typenames;
}