export default function blackBoxTest(name: string) {
  const generators = new Generators()

  const modelPath = path.join(__dirname, `cases/${name}/model.graphql`)
  const prismaPath = path.join(__dirname, `cases/${name}/prisma.graphql`)

  expect(fs.existsSync(modelPath))
  expect(fs.existsSync(prismaPath))

  const model = fs.readFileSync(modelPath, { encoding: 'UTF-8' })
  const prisma = fs.readFileSync(prismaPath, { encoding: 'UTF-8' })

  const types = DatamodelParser.parseFromSchemaString(model)
  const ourSchema = generators.schema.generate(types, {})


  const ourPrintedSchema = printSchema(ourSchema)

  // Write a copy of the generated schema to the FS, for debugging
  fs.writeFileSync(
    path.join(__dirname, `cases/${name}/generated.graphql`),
    ourPrintedSchema,
    { encoding: 'UTF-8' },
  )

  // Check if our schema equals the prisma schema. 
  const prismaSchema = buildSchema(prisma)
  AstTools.assertTypesEqual(prismaSchema, ourSchema)

  // Check if we can parse the schema we build (e.g. it's syntactically valid).
  parse(ourPrintedSchema)
}

 .then(response => {
   const schema = JSON.parse(response.body).data
   const sdl = printSchema(buildClientSchema(schema))
   const parsedSdl = parse(sdl)
   const mutatedSdl = visit(parsedSdl, {
     ObjectTypeDefinition: {
       enter(node: ObjectTypeDefinitionNode) {
         if (
           !['Query', 'Mutation', 'Subscription'].includes(node.name.value)
         ) {
           const nodeWithValidFields = visit(node, {
             FieldDefinition: {
               enter: (fieldNode: FieldDefinitionNode) => {
                 if (
                   (fieldNode.arguments &&
                     fieldNode.arguments.length > 0 &&
                     fieldNode.type.kind === 'NamedType') ||
                   (fieldNode.type.kind === 'NonNullType' &&
                     !isScalarType(fieldNode.type))
                 ) {
                   return {
                     ...fieldNode,
                     arguments: fieldNode.arguments
                       ? fieldNode.arguments.filter(
                           arg => arg.name.value !== 'where',
                         )
                       : [],
                   }
                 } else {
                   return fieldNode
                 }
               },
             },
           })
           return nodeWithValidFields
         }
       },
     },
     EnumTypeDefinition: {
       enter(enumNode: EnumTypeDefinitionNode) {
         if (enumNode.name.value === 'PrismaDatabase') {
           return null
         }
       },
     },
     FieldDefinition: {
       enter(fieldNode: FieldDefinitionNode) {
         if (fieldNode.name.value === 'executeRaw') {
           return null
         }
       },
     },
   })
   console.log(print(mutatedSdl))
 })

/**
 * Exports a PostGraphQL schema by looking at a Postgres client.
 */
export default async function exportPostGraphQLSchema (
  schema: GraphQLSchema,
  options: {
    exportJsonSchemaPath?: string,
    exportGqlSchemaPath?: string,
  } = {},
): Promise<void> {
  // JSON version
  if (typeof options.exportJsonSchemaPath === 'string') {
    const result = await graphql(schema, introspectionQuery)
    await writeFileAsync(options.exportJsonSchemaPath, JSON.stringify(result, null, 2))
  }

  // Schema language version
  if (typeof options.exportGqlSchemaPath === 'string') {
    await writeFileAsync(options.exportGqlSchemaPath, printSchema(schema))
  }
}

/**
 * Computes a prisma OpenCRUD schema for a given model.
 * @param model The model in SDL as string.
 * @returns The OpenCRUD schema as prettified string for the given model. 
 */
export default function generateCRUDSchemaString(model: string) : string {
  return printSchema(generateCRUDSchema(model))
}

function main() {
    console.log(printSchema(schema));
}

/**
 * Computes a prisma OpenCRUD schema for a given model.
 * @param model The model in SDL as string.
 * @param databaseType: The database type implementation to use.
 * @returns The OpenCRUD schema as prettified string for the given model.
 */
export default function generateCRUDSchemaString(
  model: string,
  databaseType: DatabaseType = DatabaseType.postgres,
): string {
  return printSchema(generateCRUDSchema(model, databaseType))
}