// Em time.zig (ou crie um novo arquivo relativedelta.zig e importe)

pub const RelativeDelta = struct {
    years: i32 = 0,
    months: i32 = 0,
    days: i32 = 0,
    hours: i32 = 0,
    minutes: i32 = 0,
    seconds: i32 = 0,

    pub fn init(fields: struct {
        years: i32 = 0,
        months: i32 = 0,
        days: i32 = 0,
        hours: i32 = 0,
        minutes: i32 = 0,
        seconds: i32 = 0,
    }) RelativeDelta {
        return .{
            .years = fields.years,
            .months = fields.months,
            .days = fields.days,
            .hours = fields.hours,
            .minutes = fields.minutes,
            .seconds = fields.seconds,
        };
    }

    // Helpers úteis (muito usados depois)
    pub fn isZero(self: RelativeDelta) bool {
        return self.years == 0 and
            self.months == 0 and
            self.days == 0 and
            self.hours == 0 and
            self.minutes == 0 and
            self.seconds == 0;
    }

    pub fn inSeconds(self: RelativeDelta) i64 {
        return @as(i64, self.years) * 365 * 24 * 60 * 60 +
            @as(i64, self.months) * 30 * 24 * 60 * 60 +
            @as(i64, self.days) * 24 * 60 * 60 +
            @as(i64, self.hours) * 60 * 60 +
            @as(i64, self.minutes) * 60 +
            @as(i64, self.seconds);
    }

    pub fn inDays(self: RelativeDelta) i64 {
        return @as(i64, self.years) * 365 +
            @as(i64, self.months) * 30 +
            @as(i64, self.days);
    }

    pub fn normalize(self: *RelativeDelta) void {
        // Normaliza meses → anos + meses
        if (self.months >= 12 or self.months <= -12) {
            const carry = @divTrunc(self.months, 12);
            self.years += carry;
            self.months -= carry * 12;
        }

        // Normaliza segundos → minutos + segundos
        if (self.seconds >= 60 or self.seconds <= -60) {
            const carry = @divTrunc(self.seconds, 60);
            self.minutes += carry;
            self.seconds -= carry * 60;
        }

        // Normaliza minutos → horas + minutos
        if (self.minutes >= 60 or self.minutes <= -60) {
            const carry = @divTrunc(self.minutes, 60);
            self.hours += carry;
            self.minutes -= carry * 60;
        }

        // Normaliza horas → dias + horas
        if (self.hours >= 24 or self.hours <= -24) {
            const carry = @divTrunc(self.hours, 24);
            self.days += carry;
            self.hours -= carry * 24;
        }
    }
};