import { AxiosResponse, Method } from 'axios'
import log from 'loglevel'
import { bank_endpoint, EndpointCreator, market_endpoint, Session } from '../session'
import { TricksterAccount, TricksterInventory, TricksterItem } from '../trickster'
import { BankEndpoint, LTOApi } from './api'

export const pathIsBank = (path: string): boolean => {
  if (path.includes('/')) {
    return false
  }
  return true
}

export const splitPath = (path: string): [string, string] => {
  const spl = path.split('/')
  switch (spl.length) {
    case 1:
      return [spl[0], '']
    case 2:
      return [spl[0], spl[1]]
  }
  return ['', '']
}
export class LTOApiv0 implements LTOApi {
  s: Session
  constructor(s: Session) {
    this.s = s
  }

  BankAction = async <T, D>(e: BankEndpoint, t: T): Promise<D> => {
    let VERB: Method | 'POSTFORM' = 'POST'
    let endpoint: EndpointCreator = bank_endpoint
    switch (e) {
      case 'buy-from-order':
      case 'cancel-order':
        endpoint = market_endpoint
      case 'sell-item':
        VERB = 'POSTFORM'
      default:
    }
    return this.s.request(VERB as any, e, t, endpoint).then(x => {
      return x.data
    })
  }
  GetInventory = async (char_path: string): Promise<TricksterInventory> => {
    if (char_path.startsWith(':')) {
      char_path = char_path.replace(':', '')
    }
    const type = char_path.includes('/') ? 'char' : 'account'
    return this.s
      .request('GET', `v3/item-manager/items/${type}/${char_path}`, undefined)
      .then((ans: AxiosResponse) => {
        const o = ans.data
        log.debug('GetInventory', o)
        let name = 'bank'
        let id = 0
        let galders = 0
        if (pathIsBank(char_path)) {
          const [char, val] = Object.entries(o.characters)[0] as [string, any]
          name = val.name
          id = Number(char)
          galders = 0
        } else {
          const [char, val] = Object.entries(o.characters)[0] as [string, any]
          name = val.name
          id = Number(char)
          galders = val.galders
        }
        const out: TricksterInventory = {
          account_name: o.account.account_gid,
          account_id: o.account.account_code,
          name,
          id,
          path: char_path,
          galders,
          items: new Map(
            (Object.entries(o.items) as any).map(
              ([k, v]: [string, TricksterItem]): [string, TricksterItem] => {
                v.unique_id = Number(k)
                v.id = k
                return [k, v]
              },
            ),
          ),
        }
        return out
      })
  }
  GetAccounts = async (): Promise<TricksterAccount[]> => {
    return this.s.request('GET', 'characters/list', undefined).then((ans: AxiosResponse) => {
      log.debug('GetAccounts', ans.data)
      return ans.data.map((x: any): TricksterAccount => {
        return {
          name: x.name,
          characters: [
            {
              account_name: x.name,
              id: x.id,
              account_id: x.id,
              path: x.name,
              name: `${x.name}/bank`,
              class: -8,
              base_job: -8,
              current_job: -8,
            },
            ...Object.values(x.characters).map((z: any) => {
              return {
                account_name: x.name,
                account_id: x.id,
                id: z.id,
                name: z.name,
                path: `${x.name}/${z.name}`,
                class: z.class,
                base_job: z.base_job,
                current_job: z.current_job,
              }
            }),
          ],
        }
      })
    })
  }
  GetLoggedin = async (): Promise<boolean> => {
    return this.s.request('POST', 'accounts/list', undefined).then((ans: AxiosResponse) => {
      if (ans.status === 401) {
        return false
      }
      if (ans.status === 200) {
        return true
      }
      return false
    })
  }
}