const { sortBy } = require('lodash')
const { parse, buildASTSchema } = require('graphql')
const helpers = require('./schema-helpers')

const externalScalars = require('../../../lib/graphql/non-schema-scalars')
  .map(scalar => {
    scalar.id = helpers.getId(scalar.name)
    scalar.href = helpers.getFullLink('scalars', scalar.id)
    return scalar
  })

// select and format all the data from the schema that we need for the docs
// used in the build step by script/graphql/build-static-files.js
module.exports = async function processSchemas (idl, previewsPerVersion) {
  const schemaAST = parse(idl.toString())
  const schema = buildASTSchema(schemaAST)

  // list of objects is used when processing mutations
  const objectsInSchema = schemaAST.definitions.filter(def => def.kind === 'ObjectTypeDefinition')

  const data = {}

  data.queries = {
    connections: [],
    fields: []
  }
  data.mutations = []
  data.objects = []
  data.interfaces = []
  data.enums = []
  data.unions = []
  data.inputObjects = []
  data.scalars = []

  await Promise.all(schemaAST.definitions.map(async (def) => {
    // QUERIES
    if (def.name.value === 'Query') {
      await Promise.all(def.fields.map(async (field) => {
        const query = {}
        const queryArgs = []

        query.name = field.name.value
        query.type = helpers.getType(field)
        query.kind = helpers.getTypeKind(query.type, schema)
        query.id = helpers.getId(query.type)
        query.href = helpers.getFullLink(query.kind, query.id)
        query.description = await helpers.getDescription(field.description.value)
        query.isDeprecated = helpers.getDeprecationStatus(field.directives, query.name)
        query.deprecationReason = await helpers.getDeprecationReason(field.directives, query)
        query.preview = await helpers.getPreview(field.directives, query, previewsPerVersion)

        await Promise.all(field.arguments.map(async (arg) => {
          const queryArg = {}
          queryArg.name = arg.name.value
          queryArg.defaultValue = arg.defaultValue ? arg.defaultValue.value : undefined
          queryArg.type = helpers.getType(arg)
          queryArg.id = helpers.getId(queryArg.type)
          queryArg.kind = helpers.getTypeKind(queryArg.type, schema)
          queryArg.href = helpers.getFullLink(queryArg.kind, queryArg.id)
          queryArg.description = await helpers.getDescription(arg.description.value)
          queryArg.isDeprecated = helpers.getDeprecationStatus(arg.directives, queryArg.name)
          queryArg.deprecationReason = await helpers.getDeprecationReason(arg.directives, queryArg)
          queryArg.preview = await helpers.getPreview(arg.directives, queryArg, previewsPerVersion)
          queryArgs.push(queryArg)
        }))

        query.args = sortBy(queryArgs, 'name')

        // QUERY CONNECTIONS
        // QUERY FIELDS
        query.id.endsWith('connection')
          ? data.queries.connections.push(query)
          : data.queries.fields.push(query)
      }))

      return
    }

    // MUTATIONS
    if (def.name.value === 'Mutation') {
      await Promise.all(def.fields.map(async (field) => {
        const mutation = {}
        const inputFields = []
        const returnFields = []

        mutation.name = field.name.value
        mutation.kind = helpers.getKind(def.name.value)
        mutation.id = helpers.getId(mutation.name)
        mutation.href = helpers.getFullLink('mutations', mutation.id)
        mutation.description = await helpers.getDescription(field.description.value)
        mutation.isDeprecated = helpers.getDeprecationStatus(field.directives, mutation.name)
        mutation.deprecationReason = await helpers.getDeprecationReason(field.directives, mutation)
        mutation.preview = await helpers.getPreview(field.directives, mutation, previewsPerVersion)

        // there is only ever one input field argument, but loop anyway
        await Promise.all(field.arguments.map(async (field) => {
          const inputField = {}
          inputField.name = field.name.value
          inputField.type = helpers.getType(field)
          inputField.id = helpers.getId(inputField.type)
          inputField.kind = helpers.getTypeKind(inputField.type, schema)
          inputField.href = helpers.getFullLink(inputField.kind, inputField.id)
          inputFields.push(inputField)
        }))

        mutation.inputFields = sortBy(inputFields, 'name')

        // get return fields
        // first get the payload, then find payload object's fields. these are the mutation's return fields.
        const returnType = helpers.getType(field)
        const mutationReturnFields = objectsInSchema.find(obj => obj.name.value === returnType)

        if (!mutationReturnFields) console.log(`no return fields found for ${returnType}`)

        await Promise.all(mutationReturnFields.fields.map(async (field) => {
          const returnField = {}
          returnField.name = field.name.value
          returnField.type = helpers.getType(field)
          returnField.id = helpers.getId(returnField.type)
          returnField.kind = helpers.getTypeKind(returnField.type, schema)
          returnField.href = helpers.getFullLink(returnField.kind, returnField.id)
          returnField.description = await helpers.getDescription(field.description.value)
          returnField.isDeprecated = helpers.getDeprecationStatus(field.directives, returnField.name)
          returnField.deprecationReason = await helpers.getDeprecationReason(field.directives, returnField)
          returnField.preview = await helpers.getPreview(field.directives, returnField, previewsPerVersion)
          returnFields.push(returnField)
        }))

        mutation.returnFields = sortBy(returnFields, 'name')

        data.mutations.push(mutation)
      }))
      return
    }

    // OBJECTS
    if (def.kind === 'ObjectTypeDefinition') {
      // objects ending with 'Payload' are only used to derive mutation values
      // they are not included in the objects docs
      if (def.name.value.endsWith('Payload')) return

      const object = {}
      const objectImplements = []
      const objectFields = []

      object.name = def.name.value
      object.kind = helpers.getKind(def.kind)
      object.id = helpers.getId(object.name)
      object.href = helpers.getFullLink('objects', object.id)
      object.description = await helpers.getDescription(def.description.value)
      object.isDeprecated = helpers.getDeprecationStatus(def.directives, object.name)
      object.deprecationReason = await helpers.getDeprecationReason(def.directives, object)
      object.preview = await helpers.getPreview(def.directives, object, previewsPerVersion)

      // an object's interfaces render in the `Implements` section
      // interfaces do not have directives so they cannot be under preview/deprecated
      if (def.interfaces.length) {
        await Promise.all(def.interfaces.map(async (graphqlInterface) => {
          const objectInterface = {}
          objectInterface.name = graphqlInterface.name.value
          objectInterface.id = helpers.getId(objectInterface.name)
          objectInterface.href = helpers.getFullLink('interfaces', objectInterface.id)
          objectImplements.push(objectInterface)
        }))
      }

      // an object's fields render in the `Fields` section
      if (def.fields.length) {
        await Promise.all(def.fields.map(async (field) => {
          if (!field.description) return
          const objectField = {}

          objectField.name = field.name.value
          objectField.description = await helpers.getDescription(field.description.value)
          objectField.type = helpers.getType(field)
          objectField.id = helpers.getId(objectField.type)
          objectField.kind = helpers.getTypeKind(objectField.type, schema)
          objectField.href = helpers.getFullLink(objectField.kind, objectField.id)
          objectField.arguments = await helpers.getArguments(field.arguments, schema)
          objectField.isDeprecated = helpers.getDeprecationStatus(field.directives)
          objectField.deprecationReason = await helpers.getDeprecationReason(field.directives, objectField)
          objectField.preview = await helpers.getPreview(field.directives, objectField, previewsPerVersion)

          objectFields.push(objectField)
        }))
      }

      if (objectImplements.length) object.implements = sortBy(objectImplements, 'name')
      if (objectFields.length) object.fields = sortBy(objectFields, 'name')

      data.objects.push(object)
      return
    }

    // INTERFACES
    if (def.kind === 'InterfaceTypeDefinition') {
      const graphqlInterface = {}
      const interfaceFields = []

      graphqlInterface.name = def.name.value
      graphqlInterface.kind = helpers.getKind(def.kind)
      graphqlInterface.id = helpers.getId(graphqlInterface.name)
      graphqlInterface.href = helpers.getFullLink('interfaces', graphqlInterface.id)
      graphqlInterface.description = await helpers.getDescription(def.description.value)
      graphqlInterface.isDeprecated = helpers.getDeprecationStatus(def.directives)
      graphqlInterface.deprecationReason = await helpers.getDeprecationReason(def.directives, graphqlInterface)
      graphqlInterface.preview = await helpers.getPreview(def.directives, graphqlInterface, previewsPerVersion)

      // an interface's fields render in the "Fields" section
      if (def.fields.length) {
        await Promise.all(def.fields.map(async (field) => {
          if (!field.description) return
          const interfaceField = {}

          interfaceField.name = field.name.value
          interfaceField.description = await helpers.getDescription(field.description.value)
          interfaceField.type = helpers.getType(field)
          interfaceField.id = helpers.getId(interfaceField.type)
          interfaceField.kind = helpers.getTypeKind(interfaceField.type, schema)
          interfaceField.href = helpers.getFullLink(interfaceField.kind, interfaceField.id)
          interfaceField.arguments = await helpers.getArguments(field.arguments, schema)
          interfaceField.isDeprecated = helpers.getDeprecationStatus(field.directives)
          interfaceField.deprecationReason = await helpers.getDeprecationReason(field.directives, interfaceField)
          interfaceField.preview = await helpers.getPreview(field.directives, interfaceField, previewsPerVersion)

          interfaceFields.push(interfaceField)
        }))
      }

      graphqlInterface.fields = sortBy(interfaceFields, 'name')

      data.interfaces.push(graphqlInterface)
      return
    }

    // ENUMS
    if (def.kind === 'EnumTypeDefinition') {
      const graphqlEnum = {}
      const enumValues = []

      graphqlEnum.name = def.name.value
      graphqlEnum.kind = helpers.getKind(def.kind)
      graphqlEnum.id = helpers.getId(graphqlEnum.name)
      graphqlEnum.href = helpers.getFullLink('enums', graphqlEnum.id)
      graphqlEnum.description = await helpers.getDescription(def.description.value)
      graphqlEnum.isDeprecated = helpers.getDeprecationStatus(def.directives)
      graphqlEnum.deprecationReason = await helpers.getDeprecationReason(def.directives, graphqlEnum)
      graphqlEnum.preview = await helpers.getPreview(def.directives, graphqlEnum, previewsPerVersion)

      await Promise.all(def.values.map(async (value) => {
        const enumValue = {}
        enumValue.name = value.name.value
        enumValue.description = await helpers.getDescription(value.description.value)
        enumValues.push(enumValue)
      }))

      graphqlEnum.values = sortBy(enumValues, 'name')

      data.enums.push(graphqlEnum)
      return
    }

    // UNIONS
    if (def.kind === 'UnionTypeDefinition') {
      const union = {}
      const possibleTypes = []

      union.name = def.name.value
      union.kind = helpers.getKind(def.kind)
      union.id = helpers.getId(union.name)
      union.href = helpers.getFullLink('unions', union.id)
      union.description = await helpers.getDescription(def.description.value)
      union.isDeprecated = helpers.getDeprecationStatus(def.directives)
      union.deprecationReason = await helpers.getDeprecationReason(def.directives, union)
      union.preview = await helpers.getPreview(def.directives, union, previewsPerVersion)

      // union types do not have directives so cannot be under preview/deprecated
      await Promise.all(def.types.map(async (type) => {
        const possibleType = {}
        possibleType.name = type.name.value
        possibleType.id = helpers.getId(possibleType.name)
        possibleType.href = helpers.getFullLink('objects', possibleType.id)
        possibleTypes.push(possibleType)
      }))

      union.possibleTypes = sortBy(possibleTypes, 'name')

      data.unions.push(union)
      return
    }

    // INPUT OBJECTS
    // NOTE: input objects ending with `Input` are NOT included in the v4 input objects sidebar
    // but they are still present in the docs (e.g., https://developer.github.com/v4/input_object/acceptenterpriseadministratorinvitationinput/)
    // so we will include them here
    if (def.kind === 'InputObjectTypeDefinition') {
      const inputObject = {}
      const inputFields = []

      inputObject.name = def.name.value
      inputObject.kind = helpers.getKind(def.kind)
      inputObject.id = helpers.getId(inputObject.name)
      inputObject.href = helpers.getFullLink('input-objects', inputObject.id)
      inputObject.description = await helpers.getDescription(def.description.value)
      inputObject.isDeprecated = helpers.getDeprecationStatus(def.directives)
      inputObject.deprecationReason = await helpers.getDeprecationReason(def.directives, inputObject)
      inputObject.preview = await helpers.getPreview(def.directives, inputObject, previewsPerVersion)

      if (def.fields.length) {
        await Promise.all(def.fields.map(async (field) => {
          const inputField = {}

          inputField.name = field.name.value
          inputField.description = await helpers.getDescription(field.description.value)
          inputField.type = helpers.getType(field)
          inputField.id = helpers.getId(inputField.type)
          inputField.kind = helpers.getTypeKind(inputField.type, schema)
          inputField.href = helpers.getFullLink(inputField.kind, inputField.id)
          inputField.isDeprecated = helpers.getDeprecationStatus(field.directives)
          inputField.deprecationReason = await helpers.getDeprecationReason(field.directives, inputField)
          inputField.preview = await helpers.getPreview(field.directives, inputField, previewsPerVersion)

          inputFields.push(inputField)
        }))
      }

      inputObject.inputFields = sortBy(inputFields, 'name')

      data.inputObjects.push(inputObject)
      return
    }

    // SCALARS
    if (def.kind === 'ScalarTypeDefinition') {
      const scalar = {}
      scalar.name = def.name.value
      scalar.kind = helpers.getKind(def.kind)
      scalar.id = helpers.getId(scalar.name)
      scalar.href = helpers.getFullLink('scalars', scalar.id)
      scalar.description = await helpers.getDescription(def.description.value)
      scalar.isDeprecated = helpers.getDeprecationStatus(def.directives)
      scalar.deprecationReason = await helpers.getDeprecationReason(def.directives, scalar)
      scalar.preview = await helpers.getPreview(def.directives, scalar, previewsPerVersion)
      data.scalars.push(scalar)
    }
  }))

  // add non-schema scalars and sort all scalars alphabetically
  data.scalars = sortBy(data.scalars.concat(externalScalars), 'name')

  // sort all the types alphabetically
  data.queries.connections = sortBy(data.queries.connections, 'name')
  data.queries.fields = sortBy(data.queries.fields, 'name')
  data.mutations = sortBy(data.mutations, 'name')
  data.objects = sortBy(data.objects, 'name')
  data.interfaces = sortBy(data.interfaces, 'name')
  data.enums = sortBy(data.enums, 'name')
  data.unions = sortBy(data.unions, 'name')
  data.inputObjects = sortBy(data.inputObjects, 'name')
  data.scalars = sortBy(data.scalars, 'name')

  return data
}