day_of_week -> Int4,
        start_time -> Time,
        end_time -> Time,

        start_time -> Timestamptz,
        duration -> Int4,

use chrono::{DateTime, NaiveTime, Utc};

use chrono::{DateTime, Utc};

            .select((
                rn::ts,
                rn::day_of_week,
                rn::start_time,
                rn::end_time,
                rn::observed_instances,
            ))

            .select((rn::ts, rn::start_time, rn::duration, rn::observed_instances))

    pub day_of_week: i32,
    pub start_time: NaiveTime,
    pub end_time: NaiveTime,

    pub start_time: DateTime<Utc>,
    pub duration: i32,

fn daytime_interval(dur: Duration, interval: u32) -> NaiveTime {
    let hour = (dur.num_hours() - 24 * dur.num_days()) as u32;
    let min = (dur.num_minutes() - 60 * dur.num_hours()) as u32;
    let min = if min % interval >= interval / 2 {
        min + (interval - min % interval)
    } else {
        min - (min % interval)
    };

trait RoundTo {
    fn round_to(&self, minutes: u32) -> Self;
}

    let (hour, min) = if min == 60 {
        (hour + 1, 0)

fn round_offset(min: u32, interval: u32) -> Duration {
    if min % interval >= interval / 2 {
        Duration::minutes((interval - min % interval) as i64)

        (hour, min)
    };

        -Duration::minutes((min % interval) as i64)
    }
}

    let sec = 0;

impl<Tz: chrono::TimeZone> RoundTo for DateTime<Tz> {
    fn round_to(&self, minutes: u32) -> Self {
        let min = self.minute();
        self.clone() + round_offset(min, minutes) - Duration::seconds(self.second() as i64)
    }
}

    NaiveTime::from_hms(hour, min, sec)

impl RoundTo for Duration {
    fn round_to(&self, minutes: u32) -> Self {
        let min = self.num_minutes();
        let sec = self.num_seconds() - self.num_minutes() * 60;
        self.clone() + round_offset(min as u32, minutes) - Duration::seconds(sec)
    }

// Returns a duration representing the time from the 00:00:00 on Sunday

// Returns a duration representing the time from the 00:00:00 on Sunday. used for sorting. not
// stored

#[derive(Debug, Clone)]

    start_time: Duration,
    end_time: Duration,

    start_time: DateTime<Utc>,
    duration: Duration,

fn into_raid_night(data: &mut Vec<RNData>) -> (u32, NaiveTime, NaiveTime, usize) {
    data.sort_by_key(|d| d.end_time);
    let med_end_time = data[data.len() / 2].end_time.clone();
    data.sort_by_key(|d| d.start_time);
    let med_start = &data[data.len() / 2];

fn into_raid_night(data: &mut Vec<RNData>) -> (DateTime<Utc>, Duration, usize) {
    data.sort_by_key(|d| d.duration);
    let p10 = (data.len() as f32 * 0.3).ceil() as usize - 1;
    let p90 = (data.len() as f32 * 0.7).ceil() as usize - 1;
    let end_time = data[p90].duration.clone();
    data.sort_by_key(|d| weekpoint(d.start_time));
    let med_start = &data[p10];
    debug!("times {} {} {:?}", p10, p90, data);

        med_start.log_start.weekday().num_days_from_sunday(),
        daytime_interval(med_start.start_time, 30),
        daytime_interval(med_end_time, 30),

        med_start.start_time.round_to(30),
        end_time.round_to(30),

        let start_time = weekpoint(log_start_time + Duration::milliseconds(fight_start as i64));
        let end_time = weekpoint(log_start_time + Duration::milliseconds(fight_end as i64));

        let start_time = log_start_time + Duration::milliseconds(fight_start as i64);
        let duration = Duration::milliseconds(fight_end as i64);

            end_time,

            duration,

            let diff = start_time - *prev_start_time;

            let diff = weekpoint(start_time) - weekpoint(*prev_start_time);

                debug!("difference is over 6hrs, partitioning");

            end_time,

            duration,

                    .map(|(day, start_time, end_time, count)| RaidNight {

                    .map(|(start_time, duration, count)| RaidNight {

                        day_of_week: day as i32,

                        end_time,

                        duration: duration.num_milliseconds() as i32,

  day_of_week integer not null,
  start_time time not null,
  end_time time not null,

  -- we store the start time with date here because trying to store the time of
  -- day just causes headaches with TZ conversions and raid times that go past
  -- the 23:59 mark
  start_time timestamp with time zone not null,
  duration integer not null,

export function time_date(time: string, day: number = 0): Result<Date, 'invalid time'> {
  const date = new Date(`January ${3 + day}, 2021 ${time} GMT+00:00`);

  if(date) {
    return Ok(date);
  } else {
    return Err('invalid time' as const);
  }
}

  const start_date = time_date(rn.startTime, rn.dayOfWeek); 
  const end_date = time_date(rn.endTime);

  const start_date = new Date(rn.startTime);
  const end_date = new Date(start_date.valueOf() + rn.duration);

  if (start_date.ok && end_date.ok) {
    const day = new Intl.DateTimeFormat('en-US', { weekday: 'short' }).format(start_date.val);
    const start = new Intl.DateTimeFormat('en-US', { hour: 'numeric', minute: 'numeric' }).format(start_date.val);
    const end = new Intl.DateTimeFormat('en-US', { hour: 'numeric', minute: 'numeric', timeZoneName: 'short' }).format(end_date.val);

  if (start_date && end_date) {
    const day = new Intl.DateTimeFormat('en-US', { weekday: 'short' }).format(start_date);
    const start = new Intl.DateTimeFormat('en-US', { hour: 'numeric', minute: 'numeric' }).format(start_date);
    const end = new Intl.DateTimeFormat('en-US', { hour: 'numeric', minute: 'numeric', timeZoneName: 'short' }).format(end_date);

import { ZONE_ENCOUNTERS, toRegion, ENCOUNTER_NAMES, DIFFICULTY_NAMES } from './model';
import { formatRaidTime, formatShortDate, formatDuration, time_date } from './format';

import { ZONE_ENCOUNTERS, toRegion, Region, regionReset, ENCOUNTER_NAMES, DIFFICULTY_NAMES } from './model';
import { formatRaidTime, formatShortDate, formatDuration } from './format';

        dayOfWeek,

        endTime,

        duration,

  dayOfWeek: number;
  startTime: string;
  endTime: string;

  startTime: Date;
  duration: number;

function TeamOverview(props: { team: number; zone: number; encounters: number[] }) {

function TeamOverview(props: { team: number; zone: number; encounters: number[]; region: Region; }) {

  console.log(data);

    const nights = data.teamStats.raidNights.filter((rn: RaidNight) => rn.observedInstances >= threshold);
    const mins = nights.reduce((sum: number, rn: RaidNight) => {
      const start = time_date(rn.startTime, rn.dayOfWeek).unwrap();
      let end = time_date(rn.endTime, rn.dayOfWeek).unwrap();
      // if end is e.g. 1am while start is 10pm, this can occur with
      // the above construction. fix it by incrementing the date
      if(end.valueOf() < start.valueOf()) {
        end = time_date(rn.endTime, rn.dayOfWeek + 1).unwrap();
      }

    const reset = regionReset(props.region);
    const nights = data.teamStats.raidNights
      .filter((rn: RaidNight) => rn.observedInstances >= threshold)
      .map((rn: RaidNight) => ({ ...rn, startTime: new Date(rn.startTime) }))
      .sort((a: RaidNight, b: RaidNight) => ((7 + a.startTime.getDay() - reset) % 7) - ((7 + b.startTime.getDay() - reset) % 7));

      return sum + (end.valueOf() - start.valueOf());
    }, 0) / 1000 / 60;

    const mins = nights.reduce((sum: number, rn: RaidNight) => sum + rn.duration, 0) / 1000 / 60;

          <dt className="font-bold">Raid Times:</dt>
          <dd>
            {nights.map((rn: RaidNight) => {
              return <div>{formatRaidTime(rn).unwrap()}</div>;
            })}
          </dd>

          </dd>
          <dt className="font-bold">Raid Times:</dt>
          <dd className="text-right w-min -ml-2">
            {nights.map((rn: RaidNight, ix: number) => {
              // TODO: sort by day of week offset by raid reset
              return <div key={ix}>{formatRaidTime(rn).unwrap()}</div>;
            })}

          <TeamOverview team={team.id} zone={tier} encounters={encounters} />

          <TeamOverview team={team.id} zone={tier} encounters={encounters} region={toRegion(data.guild.regionSlug)}/>