const osprey = require('osprey')
const express = require('express')
const join = require('path').join
const app = express()

const path = join(__dirname, 'assets', 'api.raml')

// Be careful, this uses all middleware functions by default. You might just
// want to use each one separately instead - `osprey.server`, etc.
osprey.loadFile(path)
  .then(function (middleware) {
    app.use(middleware)

    app.use(function (err, req, res, next) {
      // Handle errors.
    })

    app.listen(3000)
  })
   .catch(function(e) { console.error("Error: %s", e.message); });

const wap = require('webapi-parser').WebApiParser

// webapi-parser.WebApiDocument
const model = wap.raml10.parse('/some/api.raml')
const handler = osprey.server(model, options)

console.log(handler) //=> function (req, res, next) {}

console.log(handler.ramlUriParameters) //=> {} // A merged object of used URI parameters.

app.post('/users/{userId}', function (req, res, next) {
  req.form.on('field', function (name, value) {
    console.log(name + '=' + value)
  })

  req.form.on('file', function (name, stream, filename) {
    stream.pipe(fs.createWriteStream(join(os.tmpDir(), filename)))
  })

  req.form.on('error', next)

  req.pipe(req.form)
})

// Similar to `express.Router`, but uses RAML paths.
const Router = require('osprey').Router
const utils = require('./utils')

// Array<webapi-parser.Parameter>
const parameters = utils.getUriParameters()

const app = new Router()

app.use(...)

app.get('/{slug}', parameters, function (req, res) {
  res.send('success')
})

module.exports = app

const handler = osprey.server(model)
const router = osprey.Router({ ramlUriParameters: handler.ramlUriParameters })

// Uses an existing `userId` URI parameter, if it exists.
router.get('/{userId}', function (req, res, next) {})

const http = require('http')
const osprey = require('osprey')
const finalhandler = require('finalhandler')
const join = require('path').join

osprey.loadFile(join(__dirname, 'api.raml'))
  .then(function (middleware) {
    http.createServer(function (req, res) {
      middleware(req, res, finalhandler(req, res))
    }).listen(process.env.PORT || 3000)
  })
   .catch(function(e) { console.error("Error: %s", e.message); });

osprey.addJsonSchema(schema, key)

const osprey = require('osprey')
const app = require('express')()

// It's best to use the default responder, but it's overridable if you need it.
app.use(osprey.errorHandler(function (req, res, errors, stack) { /* Override */ }, 'en'))

interface CustomMessages {
  [type: string]: {
    [keyword: string]: {
      [language: string]: (error: RequestError) => string
    }
  }
}

interface RequestError {
  type: 'json' | 'form' | 'headers' | 'query' | 'xml' | string
  message: string /* Merged with i18n when available */
  keyword: string /* Keyword that failed validation */
  id?: string /* A unique identifier for the instance of this error */
  dataPath?: string /* Natural path to the error message (E.g. JSON Pointers when using JSON) */
  data?: any /* The data that failed validation */
  schema?: any /* The schema value that failed validation */
  detail?: string /* Additional details about this specific error instance */
  meta?: { [name: string]: string } /* Meta data from the error (XML validation provides a code, column, etc.) */
}

// model is an instance of webapi-parser WebApiDocument
osprey.security(model, options)

// model is an instance of webapi-parser WebApiDocument
osprey.security(model, {
  oauth_2_0: {
    // Optionally override `accessTokenUri` and `authorizationUri` when needed.
    // They need to match the suffix defined in the security scheme.
    accessTokenUri: '/oauth/token',
    authorizationUri: '/oauth/authorize',
    // Serialize the client object into the session.
    serializeClient: function (application, done) {
      return done(null, application.id)
    },
    // Deserialize client objects out of the session.
    deserializeClient: function (id, done) {
      Client.findById(id, function (err, client) {
        done(err, client)
      })
    },
    authorizeClient: function (clientId, redirectUri, scope, type, done) {
      Clients.findOne(clientId, function (err, client) {
        if (err) { return done(err) }
        if (!client) { return done(null, false) }
        if (!client.redirectUri != redirectUri) { return done(null, false) }
        return done(null, client, client.redirectUri)
      })
    },
    authenticateClient: function (clientId, clientSecret, done) {
      Clients.findOne({ clientId: clientId }, function (err, client) {
        if (err) { return done(err) }
        if (!client) { return done(null, false) }
        if (client.clientSecret != clientSecret) { return done(null, false) }
        return done(null, client)
      })
    },
    findUserByToken: function (token, done) {
      User.findOne({ token: token }, function (err, user) {
        if (err) { return done(err) }
        if (!user) { return done(null, false) }
        return done(null, user, { scope: 'all' })
      })
    },
    // An array of unique session keys to sign and verify cookies.
    sessionKeys: ['a', 'b', 'c', ...],
    ensureLoggedIn: function (req, res, next) {
      // For example: https://github.com/jaredhanson/connect-ensure-login
    },
    immediateAuthorization: function (client, user, scope, done) {
      return done(null, false)
    },
    serveAuthorizationPage: function (req, res) {
      res.render('dialog', {
        transactionId: req.oauth2.transactionID,
        user: req.user,
        client: req.oauth2.client
      })
    },
    grant: {
      code: function (client, redirectUri, user, ares, done) {
        AuthorizationCode.create(client.id, redirectUri, user.id, ares.scope, function (err, code) {
          if (err) { return done(err) }
          done(null, code)
        })
      },
      token: function (client, user, ares, done) {
        AccessToken.create(client, user, ares.scope, function (err, accessToken) {
          if (err) { return done(err) }
          done(null, accessToken /*, params */)
        })
      }
    },
    exchange: {
      code: function (client, code, redirectUri, done) {
        AccessToken.create(client, code, redirectUri, function (err, accessToken) {
          if (err) { return done(err) }
          done(null, accessToken /*, refreshToken, params */)
        })
      },
      credentials: function (client, scope, done) {
        AccessToken.create(client, scope, function (err, accessToken) {
          if (err) { return done(err) }
          done(null, accessToken /*, refreshToken, params */)
        })
      },
      owner: function (client, username, password, scope, done) {
        AccessToken.create(client, username, password, scope, function (err, accessToken) {
          if (err) { return done(err) }
          done(null, accessToken /*, refreshToken, params */)
        })
      },
      refresh: function (client, refreshToken, scope, done) {
        AccessToken.create(client, refreshToken, scope, function (err, accessToken) {
          if (err) { return done(err) }
          done(null, accessToken /*, refreshToken, params */)
        })
      }
    }
  }
})

app.get('/foo/bar', osprey.security.scope('example'), function (req, res) {
  res.send('hello, world')
})

// model is an instance of webapi-parser WebApiDocument
osprey.security(model, {
  basic_auth: {
    realm: 'Users', // Optional.
    passReqToCallback: false, // Optional. Default value: false. If true "req" is added as the first callback argument.
    validateUser: function (username, password, done) {
      User.findOne({ username: username }, function (err, user) {
        if (err) { return done(err) }
        if (!user) { return done(null, false) }
        if (!user.verifyPassword(password)) { return done(null, false) }
        return done(null, user)
      })
    }
  }
})

// model is an instance of webapi-parser WebApiDocument
osprey.security(model, {
  digest_auth: {
    realm: 'Users', // Optional.
    domain: 'example.com', // Optional.
    findUserByUsername: function (username, done) {
      User.findOne({ username: username }, function (err, user) {
        if (err) { return done(err) }
        if (!user) { return done(null, false) }
        return done(null, user, user.password)
      })
    }
  }
})

// model is an instance of webapi-parser WebApiDocument
osprey.security(model, {
  custom_auth: function (scheme, name) {
    return {
      handler: function (options, path) {
        return function (req, res, next) {
          return next()
        }
      },
      router: function (req, res, next) {
        return next()
      }
    }
  }
})

osprey.proxy(middleware, addresses)