#include <stdint.h>
#include <stddef.h>
#include "time.h"
#include "hal/hal.h"
#include "std/string.h"

#define CMOS_PORT     0x70
#define CMOS_RETURN   0x71
#define CMOS_STATA    0x0A
#define CMOS_STATB    0x0B
#define CMOS_UIP      (1<<7)

#define SECS  0x00
#define MINS  0x02
#define HRS   0x04
#define DAY   0x07
#define MONTH 0x08
#define YEAR  0x09

void time_microdelay(void) {
  for (volatile size_t i = 0; i < 200; i++);
}

uint32_t time_cmosread(uint32_t reg) {
  io_out8(CMOS_PORT, reg);
  time_microdelay();
  return io_in8(CMOS_RETURN);
}

void time_fill(Time *time) {
  time->second = time_cmosread(SECS);
  time->minute = time_cmosread(MINS);
  time->hour   = time_cmosread(HRS);
  time->day    = time_cmosread(DAY);
  time->month  = time_cmosread(MONTH);
  time->year   = time_cmosread(YEAR);
}

void time_get(Time *time) {
  Time t1, t2;
  uint32_t sb, bcd;

  sb = time_cmosread(CMOS_STATB);
  bcd = (sb & (1<<2)) == 0;

  for (;;) {
    time_fill(&t1);
    if (time_cmosread(CMOS_STATA) & CMOS_UIP) {
      continue;
    }
    time_fill(&t2);
    if (memcmp(&t1, &t2, sizeof(t1)) == 0) {
      break;
    }
  }

  if (bcd) {
    #define CONV(x)   (t1.x = ((t1.x >> 4) * 10) + (t1.x & 0xF))
    CONV(second);
    CONV(minute);
    CONV(hour);
    CONV(day);
    CONV(month);
    CONV(year);
    #undef CONV
  }

  *time = t1;
  time->year += 2000;
}

bool time_isleap(uint32_t y) {
  return (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0));
}

const uint16_t days_before_month[12] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };

timeunix_t time_tounix(Time *time) {
  uint64_t days = 0;
  for (uint32_t y = 1970; y < time->year; y++) {
    days += time_isleap(y) ? 366 : 365;
  }

  days += days_before_month[time->month - 1];

  if (time->month > 2 && time_isleap(time->year)) {
    days += 1;
  }

  days += time->day - 1;

  uint64_t secs = days * 86400;
  secs += time->hour * 3600;
  secs += time->minute * 60;
  secs += time->second;
  return secs;
}

void timeunix_totime(timeunix_t unix, Time *time) {
  uint64_t days = unix / 86400;
  uint32_t rem = days % 86400;

  time->hour = rem / 3600;
  time->minute = (rem % 3600) / 60;
  time->second = rem % 60;

  uint32_t year = 1970;
  for (;;) {
    uint32_t ydays = time_isleap(year) ? 366 : 365;
    if (days >= ydays) {
      days -= ydays;
      year++;
    } else {
      break;
    }
  }
  time->year = year;

  bool leap = time_isleap(year);
  uint32_t month = 0;
  while (month < 11) {
    uint32_t next = days_before_month[month + 1];
    if (leap && month + 1 > 1) {
      next++;
    }
    if (days < next) {
      break;
    }
    month++;
  }

  uint32_t month_start = days_before_month[month];
  if (leap && month > 1) {
    month_start++;
  }

  time->month = month + 1;
  time->day = (days - month_start) + 1;
}

uint32_t time_totalhours(Time *time) {
  uint32_t days = 0;
  for (uint32_t y = 1970; y < time->year; y++) {
    days += time_isleap(y) ? 366 : 365;
  }

  days += days_before_month[time->month - 1];
  if (time->month > 2 && time_isleap(time->year)) {
    days += 1;
  }

  days += (time->day - 1);

  uint32_t total = days * 24 + time->hour;
  return total;
}