/* eslint-disable import/first */
/* eslint-disable import/no-namespace */
import './bootstrapper/setup'
import express from 'express'
import { makeExecutableSchema } from 'graphql-tools'
import compression from 'compression'
import bodyParser from 'body-parser'
import cookieParser from 'cookie-parser'
import { importSchema } from 'graphql-import'
import { formatError } from 'apollo-errors'
import resolvers from './resolvers'
import proxyMiddleware from './proxy'
import * as endpoints from './endpoints'
import { cookieMiddleware } from './deps/cookieMiddleware'
// import { apolloExpressMiddleware } from './deps/apolloExpress'
// import { ApolloServer } from 'apollo-server-express'
import { ApolloServer, apolloExpressMiddleware } from './apollo-fork'
import { securityOriginMiddleware } from './deps/security'
import { graphqlTracing, graphqlCacheControl } from './bootstrapper/api/ENV'

// Put together a schema
// @todo check env specifically for this
console.log('[gql] loading dynamic schema?', process.env.NODE_ENV === 'development')
// export const typeDefs = require('./generated/skava-graphql.graphql').default
export const typeDefs =
  process.env.NODE_ENV === 'development' && process.env.SHOULD_USE_DYNAMIC_SCHEMA
    ? importSchema('src/schema.graphql')
    : require('./generated/skava-graphql.graphql')

/**
 * @@perf @todo need to import graphiql & create this only with a flag
 */

// graphiqlExpress({ endpointURL: '/graphql' })

function subscribePlayground(app) {
  // GraphQL Playground, a visual editor for queries
  // app.use('/graphql', bodyParser.json(), graphqlExpress({ schema }))
  if (process.env.SHOULD_USE_GRAPHIQL) {
    console.log('[gql] adding graphiql')
    // app.use('/graphiql', graphiqlSubApp)
  }
  if (process.env.SHOULD_USE_PLAYGROUND) {
    console.log('[gql] adding playground')
    const graphqlPlayground = require('graphql-playground-middleware-express').default
    app.get(
      '/graphiql',
      graphqlPlayground({ endpoint: '/graphql', cors: false, bodyParserConfig: false })
    )
  }
}

function createServer() {
  const server = new ApolloServer({
    // These will be defined for both new or existing servers
    typeDefs,
    resolvers,
    context: {
      ...endpoints,
    },
  })
  return server
}

// @note - this middleware replaces the functionality of
// server.applyMiddleware({ app })
function createApolloMiddleware() {
  console.debug('[uxui-graphql] subscribing apollo manual override')
  const server = createServer()

  const toServerContextOptions = server.createGraphQLServerOptions.bind(server)

  const middleware = (req, res, next) => {
    console.log('[uxui-graphql] apollo request')
    const apolloMiddleware = apolloExpressMiddleware(toServerContextOptions)
    apolloMiddleware(req, res, next)

    // if we add next here, it sets headers afterwards that throw errors
    // next()
  }

  return middleware
}

function createApp() {
  // @todo re-enable continue when starting mocks
  // if (process.env.MOCK_GRAPHQL) {
  //   addMockFunctionsToSchema({
  //     schema,
  //   })
  // }

  // Initialize the app and proxy
  const app = express()
  app.use(compression())

  app.use(cookieParser(), bodyParser.json())

  app.use('/api', proxyMiddleware)

  /**
   * @see https://www.npmjs.com/package/cors
   * @see https://stackoverflow.com/questions/19743396/cors-cannot-use-wildcard-in-access-control-allow-origin-when-credentials-flag-i
   * @see https://www.npmjs.com/package/cors#enabling-cors-pre-flight
   */
  app.options('/graphql', securityOriginMiddleware)

  const apolloMiddlewareBuilt = createApolloMiddleware()
  app.use('/graphql', securityOriginMiddleware, cookieMiddleware, apolloMiddlewareBuilt)

  subscribePlayground(app)

  return app
}

export {
  createApp,
  // corsOptions,
  proxyMiddleware,
  cookieMiddleware,
}
export default createApp