#[derive(Queryable, SimpleObject)]

#[derive(Queryable, SimpleObject, Clone)]

use anyhow::Result;

use anyhow::{anyhow, Result};

            .order(fights::id)

            .order(fights::id.asc())

    let mut ilvl_min = std::f32::INFINITY;
    let mut ilvl_max = std::f32::NEG_INFINITY;

    // so much unwrap
    let ilvl_min = fightmap[&logs[0].iid]
        .iter()
        .find(|f| f.avg_ilvl.is_some())
        .and_then(|f| f.avg_ilvl)
        .ok_or(anyhow!("no ilvl data"))?;
    let ilvl_max = fightmap[&logs.last().unwrap().iid]
        .iter()
        .filter(|f| f.avg_ilvl.is_some())
        .last()
        .and_then(|f| f.avg_ilvl)
        .ok_or(anyhow!("no ilvl data"))?;

        for fight in fights {
            ilvl_min = fight.avg_ilvl.unwrap_or(ilvl_min).min(ilvl_min);
            ilvl_max = fight.avg_ilvl.unwrap_or(ilvl_max).max(ilvl_max);
        }

trait RoundTo {

pub trait RoundTo {

        + Duration::minutes(dt.minute() as i64)

    let p10 = (data.len() as f32 * 0.3).ceil() as usize - 1;

    let p10 = 0;

    let med_start = &data[p10];

    let med_start = &data[p10].start_time.clone();

    let res = (
        med_start.start_time.round_to(30),
        end_time.round_to(30),
        data.len(),
    );

    let res = (med_start.round_to(30), end_time.round_to(30), data.len());

    use crate::schema::release_dates::dsl as rd;

        .inner_join(rd::release_dates.on(rd::zone.eq(logs::zone_id)))

                .and(fights::difficulty.eq(difficulty)),

                .and(fights::difficulty.eq(difficulty))
                .and(logs::start_time.ge(rd::release_date)),

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn date_round_to() {
        let date = Utc.ymd(2020, 2, 25).and_hms(0, 12, 0);
        assert_eq!(date.round_to(30).minute(), 0);
        let date = date + Duration::minutes(3);
        assert_eq!(date.round_to(30).minute(), 30);
    }
    #[test]
    fn duration_round_to() {
        let dur = Duration::minutes(0);
        assert_eq!(dur.round_to(30).num_minutes(), 0);
        let dur = Duration::minutes(12);
        assert_eq!(dur.round_to(30).num_minutes(), 0);
        let dur = Duration::minutes(15);
        assert_eq!(dur.round_to(30).num_minutes(), 30);
        let dur = Duration::hours(27) + Duration::minutes(14) + Duration::seconds(59);
        assert_eq!(dur.round_to(30), Duration::hours(27));
        let dur = Duration::hours(27) + Duration::minutes(15);
        assert_eq!(
            dur.round_to(30),
            Duration::hours(27) + Duration::minutes(30)
        );
    }
    #[test]
    fn test_weekpoint() {
        let date = Utc.ymd(2021, 2, 25).and_hms(0, 12, 0);
        println!("{:?} {} {}", date, date.hour(), date.minute());
        assert_eq!(weekpoint(date), Duration::days(4) + Duration::minutes(12));
    }
}

      },
      listStyleType: {
        dash: '" -  "',

    sync(guildId: $id, tag: $tag, zone: $zone) {

    sync(guildId: $id, tag: $tag, zone: $zone, forceAnalysis: true) {

import Changelog from './Changelog';

      {!url && <Changelog />}

            <th colSpan={5}></th>
            <th colSpan={2} className="border-l border-gray-200 pl-2 pr-2">Avg Raid ilvl</th>
          </tr>
          <tr>

            <th className="pl-2 pr-2 border-b border-l border-gray-200">Min ilvl</th>
            <th className="pl-2 pr-2 border-b">Max ilvl</th>

            <th className="pl-2 pr-2 border-b border-l border-gray-200">Start</th>
            <th className="pl-2 pr-2 border-b">Kill</th>

    const threshold = Math.ceil(maxObserved / 2);

    const threshold = Math.min(maxObserved, 4);

import { formatDate } from './format';
const CHANGES = [
  { 
    date: '2021-02-25T23:41:00-05:00', 
    messages: [
      'Removed PTR logs from analysis.', 
      'The "Min ilvl" and "Max ilvl" fields have been replaced by "Start Raid Avg ilvl" and "Kill Raid Avg ilvl" to give a more grokkable stat.',
      'Loosened the requirement on the number of times a raid date must appear to be included in the Team Overview. If you were missing a raid date, it is probably present now.',
      'Fixed an issue in raid date calculation that was resulting in raid times being 30 minutes off.',
    ] 
  }
];
function Change({ date, messages }: { date: string; messages: string[] }) {
  return (
    <>
      <dt className="border-b border-gray-200 w-min whitespace-nowrap">{formatDate(new Date(date)!)}</dt>
      <dd className="mb-5">
        <ul className="list-dash pl-5">
          {messages.map((msg, ix) => <li key={ix}>{msg}</li>)}
        </ul>
      </dd>
    </>
  )
}
export default function Changelog() {
  return (
    <section className="mt-5">
      <header className="font-serif text-2xl">
        <legend>Recent Changes</legend>
      </header>
      <dl className="text-lg">
        {CHANGES.map((change, ix) => <Change {...change} key={ix} />)}
      </dl>
    </section>
  );
}