require('dotenv').config()
import { PrismaSelect } from '@paljs/plugins'
import { ApolloServer } from 'apollo-server-express'
import { ApolloServerPluginLandingPageGraphQLPlayground } from 'apollo-server-core'
import { applyMiddleware } from 'graphql-middleware'
import { makeExecutableSchema } from '@graphql-tools/schema'
import { GraphQLResolveInfo } from 'graphql'
import { mergeTypeDefs } from '@graphql-tools/merge'
import { createContext, Context } from './context'

// OVERRIDE
import express from 'express'
import cors from 'cors'
import _typeDefs from './graphql/typeDefs'
import _resolvers from './graphql/resolvers'
import _extendResolvers_ from './_extend_/resolvers'
import _extendTypeDefs_ from './_extend_/typeDefs'
import { IS_DEV } from './utils'
import * as REST from './rest'
import './test'
import awsServerlessExpressMiddleware from  'aws-serverless-express/middleware'
import passport from  'passport'

const resolvers = [..._resolvers, ..._extendResolvers_]
const typeDefs = mergeTypeDefs([_typeDefs, ..._extendTypeDefs_])

// OVERRIDE

export let schema = makeExecutableSchema({ typeDefs, resolvers })


// Build one sdl file have all types you can delete if you not need
// generateGraphQlSDLFile(schema)

const middleware = async (
  resolve,
  root,
  args,
  context: Context,
  info: GraphQLResolveInfo,
) => {
  const result = new PrismaSelect(info).value
  if (!result.select || Object.keys(result.select).length > 0) {
    args = {
      ...args,
      ...result,
    }
  }
  return resolve(root, args, context, info)
}

schema = applyMiddleware(schema, middleware)



const createServer =  () => {
  const server = new ApolloServer({
    schema,
    context: createContext,
    plugins: [
      ...(
        IS_DEV
          ? [
            ApolloServerPluginLandingPageGraphQLPlayground({
              // options
            }),
          ]
          : []
      ),
    ],
  })
  
  const app = express();

  app.use(cors())
  app.use(express.urlencoded({ extended: true }));
  app.use(express.json());
  app.use(passport.initialize())
  app.use(passport.session())

  if (!IS_DEV) {
    app.use(awsServerlessExpressMiddleware.eventContext())
  }

  const apiRouter = express.Router()
  const publicRouter = express.Router()
  
  app.use("/api", apiRouter)
  app.use("/public", publicRouter)

  // Enable CORS for all methods
  app.use(function(req, res, next) {
    res.header("Access-Control-Allow-Origin", "*")
    res.header("Access-Control-Allow-Headers", "*")
    next()
  })
 
  // const cognitoExpress = new CognitoExpress({
  //   region: "us-east-1",
  //   cognitoUserPoolId: "us-east-1_dXlFef73t",
  //   tokenUse: "access", //Possible Values: access | id
  //   tokenExpiration: 3600000 //Up to default expiration of 1 hour (3600000 ms)
  // });
  // app.use(function(req, res, next) {
  //   //I'm passing in the access token in header under key accessToken
  //   let accessTokenFromClient = req.headers.accesstoken;
  
  //   //Fail if token not present in header. 
  //   if (!accessTokenFromClient) return res.status(401).send("Access Token missing from header");
  
  //   cognitoExpress.validate(accessTokenFromClient, function(err, response) {
      
  //     //If API is not authenticated, Return 401 with error message. 
  //     if (err) return res.status(401).send(err);
      
  //     //Else API has been authenticated. Proceed.
  //     res.locals.user = response;
  //     next();
  //   });
  // })
  // app.use(function(req, res, next) {
  //   let userSub = event.requestContext.identity.cognitoAuthenticationProvider.split('CognitoSignIn:')[1]
  //   let UserPoolId = event.requestContext.identity.cognitoAuthenticationProvider.split(',')[0].split('/')[1]
  // })
  if (process.env.AUTH_ENABLED) {
    apiRouter.use(passport.authenticate('jwt'))
  }
  
  Object.keys(REST ?? {}).map((key) => {
    const creator = REST[key]
    creator({
      app,
      apiRouter,
      publicRouter,
    })
  })

  server.start().then(() => {
    // @ts-ignore
    server.applyMiddleware({ app: apiRouter });
    app.listen(3000, () => console.log(`Listening on: 3000`))
  })
    return {
      server,
      app,
    }
}


export default createServer()