use anyhow::Result;

use anyhow::{anyhow, Result};

use log::error;

use serde_derive::Deserialize;
use std::collections::HashMap;

#[derive(Deserialize)]
#[serde(untagged)]
enum TokenResponse {
    Ok(WclToken),
    Err(HashMap<String, String>),
}

    client

    let res = client

        .json::<WclToken>()
        .await
        .map_err(anyhow::Error::from)

        .json::<TokenResponse>()
        .await?;
    match res {
        TokenResponse::Ok(token) => Ok(token),
        TokenResponse::Err(err) => {
            error!("an error occurred while refreshing a user token: {:?}", err);
            return Err(anyhow!("unable to refresh token"));
        }
    }

    client

    let res = client

        .json::<WclToken>()
        .await
        .map_err(anyhow::Error::from)

        .json::<TokenResponse>()
        .await?;
    match res {
        TokenResponse::Ok(token) => Ok(token),
        TokenResponse::Err(err) => {
            error!("an error occurred while acquiring a user token: {:?}", err);
            return Err(anyhow!("unable to acquire token"));
        }
    }

use diesel::r2d2::{ConnectionManager, Pool, PooledConnection};

use diesel::r2d2::{ConnectionManager, Pool};

    }
    /// Whether we have access to private logs for `guild` / `zone`.
    async fn private_access(&self, ctx: &Context<'_>, guild: i32, zone: i32) -> Result<bool> {
        use crate::schema::auth_codes::dsl as auth;
        let Data { conpool, .. } = ctx.data()?;
        Ok(auth::auth_codes
            .filter(auth::team.eq(guild).and(auth::zone.eq(zone)))
            .count()
            .get_result::<i64>(&*conpool.get()?)?
            > 0)

    async fn revoke_team(&self, ctx: &Context<'_>, code: String, team: i64) -> Result<bool> {
        todo!()

    async fn revoke_team(
        &self,
        ctx: &Context<'_>,
        code: String,
        team: i64,
        zone: i64,
    ) -> Result<bool> {
        use crate::schema::{auth_codes::dsl as auth, teams::dsl as teams};
        let Data {
            client,
            conpool,
            secrets,
            ..
        } = ctx.data()?;
        let token = crate::user_auth::token_for_code(&client, &secrets, &code).await?;
        if !user_validation::privileged_user(&client, &token, team, zone).await? {
            return Ok(false);
        }
        let con = conpool.get()?;
        con.transaction::<_, anyhow::Error, _>(|| {
            // it says team, it means guild.
            diesel::delete(auth::auth_codes.filter(auth::team.eq(team as i32))).execute(&con)?;
            // not liking the extra round-trips here but w/e
            let (guild_name, region, server): (String, String, String) = teams::teams
                .filter(teams::id.eq(team as i32))
                .select((teams::name, teams::region_slug, teams::server_slug))
                .first(&con)?;
            diesel::delete(
                teams::teams.filter(
                    teams::name
                        .eq(guild_name)
                        .and(teams::region_slug.eq(region))
                        .and(teams::server_slug.eq(server)),
                ),
            )
            .execute(&con)?;
            Ok(())
        })?;
        Ok(true)

-- Your SQL goes here
alter table team_stats
drop constraint team_stats_team_fkey,
add constraint team_stats_team_fkey foreign key (team) references teams(id) on delete cascade;
alter table encounter_stats
drop constraint encounter_stats_team_fkey,
add constraint encounter_stats_team_fkey foreign key (team) references teams(id) on delete cascade;
alter table fights
drop constraint fights_log_fkey,
add constraint fights_log_fkey foreign key (log) references logs(iid) on delete cascade;
alter table logs
drop constraint logs_team_fkey,
add constraint logs_team_fkey foreign key (team) references teams(iid) on delete cascade;
alter table raid_nights
drop constraint raid_nights_ts_fkey,
add constraint raid_nights_ts_fkey foreign key (ts) references team_stats(id) on delete cascade;

-- This file should undo anything in `up.sql`
alter table team_stats
drop constraint team_stats_team_fkey,
add constraint team_stats_team_fkey foreign key (team) references teams(id);
alter table encounter_stats
drop constraint encounter_stats_team_fkey,
add constraint encounter_stats_team_fkey foreign key (team) references teams(id);
alter table fights
drop constraint fights_log_fkey,
add constraint fights_log_fkey foreign key (log) references logs(iid);
alter table logs
drop constraint logs_team_fkey,
add constraint logs_team_fkey foreign key (team) references teams(iid);
alter table raid_nights
drop constraint raid_nights_ts_fkey,
add constraint raid_nights_ts_fkey foreign key (ts) references team_stats(id);

let host = 'prog-stats.emallson.net';

import { host } from './config';

if (process.env.NODE_ENV === 'development') {
  host = 'localhost:9998';
}

export let host = 'prog-stats.emallson.net';
if (process.env.NODE_ENV === 'development') {
  host = 'localhost:9998';
}

import { PreAuth } from './Auth';

import { PreAuth, RevokeAuth } from './Auth';

  query DetailsMeta($guildId: Int!, $teamId: Int!) {

  query DetailsMeta($guildId: Int!, $teamId: Int!, $zoneId: Int!) {

    privateAccess(guild: $guildId, zone: $zoneId)

  const [showRevoke, setShowRevoke] = useState(false);

    variables: { teamId: tagid || 0, guildId: guildid || 0 }

    variables: { teamId: tagid || 0, guildId: guildid || 0, zoneId: tier || 0 }

        {data && data.privateAccess && <div><button className="underline" onClick={() => setShowRevoke(true)}>Revoke Private Access</button></div>}

      <RevokeAuth zone={tier} guild={guildid} open={showRevoke} close={() => setShowRevoke(false)}/>

import { host } from './config';
Modal.setAppElement("#root");

const REDIRECT_URI = `${process.env.PUBLIC_URL || 'http://localhost:3000'}/authorize`;

const REDIRECT_URI = `${host}/authorize`;

function redirect(team: number, zone: number) {

function redirect(team: number, zone: number, kind: 'authorize' | 'revoke') {

  window.localStorage.setItem('auth_state', JSON.stringify({ state, pathname, team, zone }));

  window.localStorage.setItem('auth_state', JSON.stringify({ state, pathname, team, zone, kind }));

interface Props { open: boolean; close: () => void; guild: number; zone: number; }

export function PreAuth({ open, close, guild, zone }: { open: boolean; close: () => void; guild: number; zone: number; }) {

const modalStyle = {content: { top: 'calc(50% - 20em)', bottom: 'auto', left: 'calc(50% - 20em)', width: 'min(40em, 90vw)' }};
export function PreAuth({ open, close, guild, zone }: Props) {

    <Modal isOpen={open} contentLabel="Authorization Required" style={{content: { top: 'calc(50% - 20em)', bottom: 'auto', left: 'calc(50% - 20em)', width: 'min(40em, 90vw)' }}}>

    <Modal isOpen={open} contentLabel="Authorization Required" style={modalStyle}>

        <button onClick={redirect.bind(null, guild, zone)} className="py-2 px-4 bg-blue-200 font-bold rounded-lg shadow-md hover:bg-blue-300 focus:outline-none focus:ring-2">Continue</button>

        <button onClick={redirect.bind(null, guild, zone, 'authorize')} className="py-2 px-4 bg-blue-200 font-bold rounded-lg shadow-md hover:bg-blue-300 focus:outline-none focus:ring-2">Continue</button>

export function RevokeAuth({ open, close, guild, zone }: Props) {
  return (
    <Modal isOpen={open} contentLabel="Revoke Access?" style={modalStyle}>
      <header className="mb-2">
        <legend className="font-serif text-2xl">Revoke Private Log Access</legend>
      </header>
      <p>
        In order to revoke access to private logs, you will need to grant access via WarcraftLogs so that we can verify your identity.
      </p>
      <p className="mt-2">
        After verification, all data related to this <strong>guild</strong> will be deleted.
      </p>
      <footer className="grid gap-4 justify-end grid-flow-col mt-2">
        <button className="underline" onClick={close}>Cancel</button>
        <button onClick={redirect.bind(null, guild, zone, 'revoke')} className="py-2 px-4 bg-red-200 font-bold rounded-lg shadow-md hover:bg-red-300 focus:outline-none focus:ring-2">Revoke Access</button>
      </footer>
    </Modal>
  )
}

export default function Auth() {
  const query = new URLSearchParams(useLocation().search);
  const state = JSON.parse(window.localStorage.getItem('auth_state') || '{}');
  const nonce = query.get('state');
  const code = query.get('code');

const REVOKE = gql`
  mutation Revoke($team: Int!, $code: String!, $zone: Int!) {
    revokeTeam(code: $code, team: $team, zone: $zone)
  }
`;
interface AuthProps {
  code: string;
  team: number;
  zone: number;
  pathname: string;
}

  const [storeCode, { data, loading, error }] = useMutation(STORE_CODE, { onError: (e) => console.log(e) });

function RequestAccess({ code, team, zone, pathname }: AuthProps) {
  console.log(code, team, zone);
  const [storeCode, { called, data, loading, error }] = useMutation(STORE_CODE, { onError: (e) => console.log(e) });
  console.log(called);

    if(code && state.state === nonce) {
      setTimeout(() => storeCode({ variables: { code, ...state }}), 1000);

    if(!called) {
      storeCode({ variables: { code, team, zone }});

  }, []); // eslint-disable-line react-hooks/exhaustive-deps

  }, [code, team, zone]); // eslint-disable-line react-hooks/exhaustive-deps
  if(loading) {
    return <div>Loading...</div>;
  }
  if(error) {
    return <div>Error: {error.message}</div>;
  }

  if(!code || state.state !== nonce) {
    return <div>Invalid authorization state.</div>;

  if(data && data.storeCode) {
    return <Redirect to={pathname} />;
  } else if(data) {
    return <div>You do not have access to private or unlisted logs for that guild.</div>;

  return <div></div>;
}
function RevokeAccess({ code, team, zone }: AuthProps) {
  const [revokeTeam, { called, data, loading, error }] = useMutation(REVOKE, { onError: (e) => console.log(e) });
  useEffect(() => {
    if(!called) {
      revokeTeam({ variables: { code, team, zone }});
    }
  }, [code, team, zone]) // eslint-disable-line react-hooks/exhaustive-deps

  if(data && data.storeCode) {
    return <Redirect to={state.pathname} />;

  if(data && data.revokeTeam) {
    return <div>Team data has been deleted.</div>;

export default function Auth() {
  const query = new URLSearchParams(useLocation().search);
  const state = JSON.parse(window.localStorage.getItem('auth_state') || '{}');
  const nonce = query.get('state');
  const code = query.get('code');
  if(!code || state.state !== nonce) {
    return <div>Invalid authorization state.</div>;
  }
  switch(state.kind) {
    case 'revoke':
    return <RevokeAccess code={code} team={state.team} zone={state.zone} pathname={state.pathname} />;
    case 'authorize':
    return <RequestAccess code={code} team={state.team} zone={state.zone} pathname={state.pathname} />;
    default:
    return null;
  }
}