import { graphql } from 'graphql'
import { makeExecutableSchema } from 'graphql-tools'

import ASTParser from './ast/ASTParser'

// Construct a schema, using GraphQL schema language
const typeDefs = `
  type Team {
    id: Int
    name: String
  }

  type Player {
    id: Int
    firstName: String
    lastName: String
  }

  union Source = Team | Player

  type Participant {
    id: Int
    source: Source
  }

  type Settings {
    enabled: String
    alias: String
    ord: Int
    mode: String
    did: Int
  }

  type Custom {
    value: Boolean
    parentid: Int
  }

  type Sport {
    spid: Int
    nam: String
    isValid(sitid: Int): Boolean
    settings(did: Int): Settings
    sportHasCustomLeagueSettings(did: Int): Custom
  }

  type Query {
    sports(did: Int, sitid: Int, other: String): Sport
    participant: Participant
    isValid: Boolean
    sportSettingsV2(sitid: Int): Sport
  }
`

function parse(info) {
  const fieldNode = info.fieldNodes[0]
  const parser = new ASTParser(info)

  // parser.addArgument('sitid', sitid)
  // parser.addArgument('sitid', sitid, 'intvalue')
  // parser.addArgument('sitid', sitid, 'IntValue')

  console.time('Parsing...')
  console.log('PARSED', parser.parse())
  console.timeEnd('Parsing...')

  return ''
}

// Provide resolver functions for your schema fields
const resolvers = {
  Query: {
    sports: (root, args, context, info) => {
      const parsed = parse(info)

      return {
        spid: 1,
        nam: 'Cool',
        settings: {
          enabled: true,
          alias: 'Test',
          ord: 2,
          mode: 'Mode',
          did: 0,
        }
      }
    },

    sportSettingsV2: (root, args, context, info) => {
      const parsed = parse(info)

      return {
        spid: 1,
        nam: 'Cool',
        settings: {
          enabled: true,
          alias: 'Test',
          ord: 2,
          mode: 'Mode',
          did: 0,
        }
      }
    },

    isValid: (root, args, context, info) => {
      const parsed = parse(info)

      return true
    },
    participant: (root, args, context, info) => {
      const parsed = parse(info)

      return {
        id: 1,
        source: {
          name: 'Asdf'
        },
      }
    },
  },
  Sport: {
    isValid: (root, args, context, info) => {
      const parsed = parse(info)

      return true
    },
  },

  Source: {
    __resolveType(data) {
      if(data.name) return 'Team'

      return 'Player'
    }
  }
}

// Required: Export the GraphQL.js schema object as "schema"
export const schema = makeExecutableSchema({
  typeDefs,
  resolvers,
})

const query = `
  query Test($did: Int!, $sitid: Int = 1, $test: Boolean!) {
    sports(did: $did, sitid: 1) {
      spid @include(if: $test)
      nam
    }

    otherSports: sports(sitid: $sitid) {
      ...sportName
      isValid(sitid: $sitid)
    }

    participant {
      id
      source {
        ...on Player { firstName }
        ...on Team { name }
      }
    }

    isValid
  }

  fragment sportName on Sport {
    nam
  }
`

const query2 = `
query sports ($domainId: Int!, $sitid: Int!){
 sportSettingsV2(sitid: $sitid) {
   spid
   nam
   sportHasCustomLeagueSettings(did: $domainId) {
     value
     parentid
   }
   settings(did: $domainId) {
    enabled
    alias
    ord
    mode
    did
   }
   defaultSettings: settings(did: 0) {
    enabled
    alias
    ord
    mode
   }
 }

 sports(did: 1, other: "test") {
   nam
 }
}
`

const variables = { did: 1, sitid: 1, domainId: 0, test: true }

async function main() {
  try {
    const result = await graphql(schema, query, undefined, undefined, variables)

    console.log('result', result)
  } catch(e) {
    console.error(e)
  }
}

main()