import { GQLClient, gql } from "../client/graphql";

export async function listLogs(gql: GQLClient, filter?: LogFilter): Promise<LogHeader[]> {
  return (await gql.post(LOGS_DOC, {filter}, "ListLogs")).logs;
}

export function logFilterToQueryString(filter: LogFilter): string {
  const parts: {k:string, v:string}[] = [];

  if (filter.characters != null && filter.characters.length > 0) {
    parts.push({k:"characters", v:filter.characters.join(",")})
  }
  if (filter.channels != null && filter.channels.length > 0) {
    parts.push({k:"channels", v:filter.channels.join(",")})
  }
  if (filter.events != null && filter.events.length > 0) {
    parts.push({k:"events", v:filter.events.join(",")})
  }
  if (filter.search != null && filter.search !== "") {
    parts.push({k:"search", v:filter.search})
  }
  if (filter.open != null) {
    parts.push({k:"open", v:filter.open ? "true" : "false"})
  }
  if (filter.limit != null) {
    parts.push({k:"limit", v:filter.limit.toFixed(0)})
  } else {
    parts.push({k:"limit", v:"100"})
  }

  if (parts.length === 1 && parts[0].k === "limit" && parts[0].v === "100") {
    return "";
  }

  return "?" + parts.map(p => `${p.k}=${encodeURIComponent(p.v)}`);
}

export function logFilterFromQueryString(qs: string): LogFilter {
  const filter: LogFilter = {limit: 100};
  const qsParts = (qs.startsWith("?") ? qs.slice(1) : qs).split("&").map(t => t.split("=")).map(kv => ({
    k: kv[0],
    v: decodeURIComponent(kv[1]),
  }));

  for (const part of qsParts) {
    switch (part.k) {
      case "characters": {
        filter.characters = part.v.split(",");
        break;
      }
      case "channels": {
        filter.channels = part.v.split(",");
        break;
      }
      case "events": {
        filter.events = part.v.split(",");
        break;
      }
      case "search": {
        filter.search = part.v;
        break;
      }
      case "open": {
        filter.open = part.v === "open";
        break;
      }
      case "limit": {
        filter.limit = parseInt(part.v) || 0;
        break;
      }
    }
  }

  return filter;
}

export interface LogFilter {
  /** Character IDs */
  characters?: string[]

  /** Channel names */
  channels?: string[]

  /** Event names */
  events?: string[]

  /** Search text */
  search?: string

  /** Show only open logs */
  open?: boolean

  /** Limit the result set size. */
  limit?: number
}

export interface LogHeader extends LogCommon {
  /** Character IDs */
  characters: LogHeaderCharacter[]
}

interface LogCommon {
  id: string
  shortId: string
  date: string
  channelName: string
  title: string
  description: string
  eventName: string
  open: boolean
}

export interface LogHeaderCharacter {
  id: string
  name: string
  shortName: string
  author: string
}

const LOGS_DOC = gql`
query ListLogs($filter: LogsFilter) {
  logs(filter: $filter) {
    ...LogMeta
    ...LogMetaCharacters
  }
}

query FindLog($id: String!) {
  log(id: $id) {
    ...LogMeta
    ...LogData
  }
}

fragment LogMeta on Log {
  id
  shortId
  date
  channelName
  title
  eventName
  description
}

fragment LogMetaCharacters on Log {
  characters {
    id
    name
    shortName
    author
  }
}

fragment LogData on Log {
  open
  channel {
    name
    logged
    hub
    eventName
    locationName
  }
  characters {
    id
    nicks
    author
    name
    shortName
    description
  }
  posts {
    id
    time
    kind
    nick
    text
    position
  }
}
`;