const { MockServer } = require("@r35007/mock-server");
const mockServer = MockServer.Create({ root: __dirname });
mockServer.launchServer("./db.json");

const { MockServer } = require("@r35007/mock-server");

const mockServer = MockServer.Create({ root: __dirname }); // Create Mock Server instance with custom config.

const rewriter = mockServer.rewriter({ "/api/*": "/$1" }); // /api/posts -> /posts
const defaults = mockServer.defaults();
const resources = mockServer.resources("./db.json");
const homePage = mockServer.homePage();

const app = mockServer.app;

app.use(rewriter); // Make sure to use this at first, before all the resources
app.use(defaults); // Add default Middlewares.
app.use(resources.router); // Add Database
app.use(homePage); // Create the Mock Server Home Page

app.use(mockServer.pageNotFound); // Middleware to return `Page Not Found` as response if the route doesn't match
app.use(mockServer.errorHandler); // Default Error Handler

mockServer.startServer();

const { MockServer } = require("@r35007/mock-server");

const mockServer = MockServer.Create({ root: __dirname }); // Create Mock Server instance with custom config.

const app = mockServer.app;

// Adds Database and returns a new express router
const resources = mockServer.resources("./db.json");
app.use(resources.router);

// Add new database. This will be added to the existing database and will not override the existing route if exist
const newDb = {
  users: [
    { id: 1, name: "foo" },
    { id: 2, name: "bar" },
  ],
  profile: { name: "foo" }, // will not be added since its already exist in resource
};
const newResource = mockServer.resources(newDb);
app.use(resources.router);

mockServer.startServer();

const { MockServer } = require("@r35007/mock-server");

const mockServer = MockServer.Create({ root: __dirname }); // Create Mock Server instance with custom config.

const app = mockServer.app;

// Created new database with custom injectors and middlewares.
// These injectors and middlewares will not added to the global instance of the Mock Server
// Which means that these injectors and middleware will only be applied to todos database
const todos = {
  todos: [
    { id: 1, title: "Todo 1", completed: false },
    { id: 2, title: "Todo 2", completed: false },
  ],
};

const injectors = [{ routes: "/(.*)", delay: 1000, middlewares: ["log"] }];

const middlewares = {
  log: (req, res) => {
    console.log(req.url);
    res.send(res.locals.data);
  },
};
const todosResource = mockServer.resources(todos, {
  injectors,
  middlewares,
});
app.use(todosResource.router);

mockServer.startServer();

const { MockServer } = require("@r35007/mock-server");
const mockServer = MockServer.Create({ root: __dirname });
const app = mockServer.app;
const resources = mockServer.resources();

resources.create("/todos", (req, res, next) => {next()})
  .mock({"userId": 1 "id": 1 "title": "Marvel" "completed": false})
  .delay(1000) // delay in milliseconds
  .done(); //  Make sure to call done method to create the route.

resources.create("/photos")
  .fetch("https://jsonplaceholder.typicode.com/photos")
  .fetchCount(3);
  .done();

const dbMode = 'multi';
resources.create("/users")
  .send("https://jsonplaceholder.typicode.com/users", dbMode) // value will be to set to `mock` or `fetch` based on dbMode
  .done();

resources.create("/posts")
  .send({ userId: 1 id: 1 title: "Marvel" body: "My First post"})
  .done();

app.use(resources.router);

mockServer.startServer();

const { MockServer } = require("@r35007/mock-server");
const mockServer = MockServer.Create({ root: __dirname });
const app = mockServer.app;
const resources = mockServer.resources();

middlewares = [
  (req, res, next) => {
    next();
  },
  (req, res, next) => {
    next();
  },
];

const db = resources
  .create("/todos", ...middlewares) // can give n number of middlewares and names here
  .send("My Response", mockServer.config.dbMode) // this value will be set to `mock` or `fetch` based on dbMode. alias rely
  .id("todos")
  .description("todos route")
  .mock({ userId: 1, id: 1, title: "Marvel", completed: false })
  .fetch("https://jsonplaceholder.typicode.com/todos")
  .mockFirst(false)
  .statusCode(200) // alias status(200) can also be used
  .delay(0) // delay in milliseconds
  .fetchCount(1)
  .skipFetchError(false)
  .directUse(false)
  .headers({}) // Set response Headers
  .done({ log: true }); //  Make sure to call done method to create the route.
console.log(db);
/* db will return the generated db object. This will not be added to the mockserver db until we call done() method
{
  "/todos": {
    "id":"todos",
    "description": "todos route",
    "mock":{
      "userId": 1,
      "id": 1,
      "title": "Marvel",
      "completed": false
    },
    "fetch": "https://jsonplaceholder.typicode.com/todos",
    "mockFirst": false,
    "statusCode": 200,
    "delay": 0,
    "fetchCount": 1,
    "skipFetchError": false,
    "directUse": false,
    "headers": {}
  }
}
*/

app.use(resources.router);

mockServer.startServer();

const isAuthorized = (_req) => true;

const auth = (req, res, next) => {
  if (isAuthorized(req)) return next(); // continue to Mock Server router
  res.sendStatus(401);
};

const DataWrapper = (req, res, next) => {
  res.locals.data = {
    status: "Success",
    message: "Retrieved Successfully",
    result: res.locals.data,
  };
  next();
};

module.exports = (mockServer) => {
  const { app, routes, data, getDb, getStore } = mockServer || {};
  const { config, db, injectors, middlewares, rewriters, store } = data || {};
  // Our Global middleware logic here before setting default middlewares by the MockServer.

  return {
    _globals: [auth], // These middlewares will be used after the default middlewares
    DataWrapper, // This can used in as a specific route middleware using route configs
  };
};

const { MockServer } = require("@r35007/mock-server");

const mockServer = MockServer.Create({ root: __dirname });
const app = mockServer.app;

const defaults = mockServer.defaults();
app.use(defaults);

// Always set middlewares after using default middlewares.
// These middlewares will be set to mockServer instance and can be accessed across all routes.
mockServer.setMiddlewares("./middlewares.js");
app.use(mockServer.middlewares._globals);

const resources = mockServer.resources({
  "/fetch/users1/customMiddleware": {
    _config: true,
    fetch: "http://jsonplaceholder.typicode.com/users",
    middlewares: ["DataWrapper"], // Picks the DataWrapper middleware from middlewares.js
  },
});
app.use(resources.router); // Add Database

const db = {
  "/static/app1": express.static("./path/to/build/folder/app1")
  "/static/app2": { _config: true, middlewares: express.static("./path/to/build/folder/app2"), directUse: true }
  "/fetch/users": {
    _config: true,
    fetch: "http://jsonplaceholder.typicode.com/users",
    middlewares:(req, res) => { res.send("custom response")},
    directUse: true
  }
}

const { MockServer } = require("@r35007/mock-server");

const mockServer = MockServer.Create({ root: __dirname, dbMode: "fetch" });
const resources = mockServer.resources({
  "/posts": "http://jsonplaceholder.typicode.com/posts", // have delay of 2 seconds
  "/comments/1": "http://jsonplaceholder.typicode.com/comments/1", // sets status code of 500
  "/comments/2": "http://jsonplaceholder.typicode.com/comments/2", // sets status code of 500
});

const app = mockServer.app;

// These injectors will be set to mockServer instance and be access across all routes
mockServer.setInjectors("./injectors.json");
app.use(mockServer.middlewares._globals);

// Can also set injectors using setData
// mockServer.setData({ injectors:  "./injectors.json"});

app.use(resources.router); // Add Database

const mockServer = MockServer.Create();
const app = mockServer.app;
const rewriters = mockServer.Rewriter("./rewriters.json");
app.use(rewriters); // Make sure to use it before all the resources

// These are default config. We can provide our custom config as well.
const path = require("path");
const public = path.join(process.cwd(), "public");
const config = {
  port: 3000, // Set Port to 0 to pick a random available port.
  host: "localhost", // Set Host to empty string to pick the Local Ip Address.
  root: process.cwd(), // Root path of the server. All paths refereed in db data will be relative to this path
  base: "", // Mount db on a base url
  id: "id", // Set db id attribute.
  dbMode: "mock", // Give one of 'multi', 'fetch', 'mock'
  static: public, // Path to host a static files. Give empty string to avoid hosting public folder by default
  reverse: false, // Generate routes in reverse order
  logger: true, // Enable api logger
  noCors: false, // Disable CORS
  noGzip: false, // Disable data compression
  readOnly: false, // Allow only GET calls
  bodyParser: true, // Enable body-parser
  cookieParser: true, // Enable cookie-parser
  quiet: false, // Disable console logs
};

new MockServer(config).launchServer("./db.json");

const db = {
  route1: "My Response", // "/route1": { _config: true, mock: "My Response" }
  route2: { data: "My Response" }, // "/route2": { _config: true, mock: { data: "My Response" } }
  route3: [], // "/route3": { _config: true, mock: [] }
  route4: { _config: true, fetch: "path/to/file" }, // "/route4": { _config: true, fetch: "path/to/file" }
};

const db = {
  route1: "path/to/file", // "/route1": { _config: true, fetch: "path/to/file"  }
  route2: { url: "path/to/file" }, // "/route2": { _config: true, fetch: { url: "path/to/file" } }
  route3: { _config: true, mock: "My Response" }, // "/route3": { _config: true, mock: "My Response" }
};

const db = {
  route1: "path/to/file", // "/route1": { _config: true, fetch: "path/to/file"  }
  route2: { data: "My Response" }, // "/route2": { _config: true, mock: { data: "My Response" } }
  route3: [], // "/route3": { _config: true, mock: [] }
  route4: { _config: true, mock: "My Response" }, // "/route4": { _config: true, mock: "My Response" }
};

const db = {
  "/fetch/users1/customMiddleware": {
    _config: true,
    fetch: "http://jsonplaceholder.typicode.com/users",
    middlewares: ["DataWrapper"], // Picks the DataWrapper middleware from middlewares.js
  },
  "/fetch/users2/customMiddleware": {
    _config: true,
    fetch: "http://jsonplaceholder.typicode.com/users",
    middlewares: (req, res, next) => {
      next();
    },
  },
};

exports._FetchTillData = (_req, res, next) => {
  const locals = res.locals;
  const routeConfig = locals.routeConfig;

  if (!routeConfig.fetchData) return next();

  if (!routeConfig.fetchData.isError) {
    // If fetchData has no error then stop fetching anymore
    routeConfig.fetchCount = 0; // setting fetchCount to zero stops fetching
  } else if (
    routeConfig.fetchCount !== undefined &&
    routeConfig.fetchCount == 0
  ) {
    // If fetchData has any error then keep on fetching
    routeConfig.fetchCount = -1; // setting fetchCount to -1 does an infinite fetch
  }
  next();
};

const { MockServer } = require("@r35007/mock-server");
const mockServer = new MockServer("./config.json");

const { MockServer } = require("@r35007/mock-server");
const mockServer = MockServer.Create("./config.json");

const { MockServer } = require("@r35007/mock-server");
let mockServer = MockServer.Create();
await MockServer.Destroy(mockServer);

mockServer.launchServer("./db.json", {
  injectors: "./injectors.json",
  middlewares: "./middleware.js",
  rewriters: "./rewriters.json",
  store: "./store.json",
  router: express.Router(),
  log: false,
});

const rewriters = mockServer.rewriter("./rewriters.json", {
  log: false,
  root: __dirname,
});
app.use(rewriters);

const defaults = mockServer.defaults({ static: "./public", readOnly: true });
app.use(defaults);

const resources = mockServer.resources("./db.json");
app.use(resources.router);

const resources = mockServer.resources("./db.json", {
  injectors: "./injectors.json",
  middlewares: "./middleware.js",
  root: __dirname,
  dbMode: "mock",
  reverse: false,
  router: express.Router();
  log: false
});

middlewares = (req, res, next) => { next() };

// /todos will be added to existing db
const db = resources
  .create("/todos", middlewares) // can give n number of middlewares and names here
  .send("My Response", 'multi') // response will set to `mock` or `fetch` based on dbMode
  .id("todos")
  .description("todos route")
  .mock({ userId: 1, id: 1, title: "Marvel", completed: false })
  .fetch("https://jsonplaceholder.typicode.com/todos")
  .mockFirst(false)
  .statusCode(200)
  .delay(0) // delay in milliseconds
  .fetchCount(1)
  .skipFetchError(false)
  .directUse(false)
  .headers({}) // set response headers
  .done();

app.use(resources.router);

const homePage = mockServer.homePage();
app.use(homePage);

const server = await mockServer.startServer(3000, "localhost");

const isStopped = await mockServer.stopServer();

mockServer.resetServer();

const routes = mockServer.resetDb(); // If param is not present, it resets all the routes.

app.use(mockServer.pageNotFound);

app.use(mockServer.errorHandler);

const MockServer = require('@r35007/mock-server').default;
const mockServer = MockServer.Create();

// Please avoid directly modify or setting values to these variable.
// Use Setter method to modify or set any values.

// server, port, address, listeningTo will be undefined when server is stopped
const  port: number | undefined; // gives current running port.
const  server: Server | undefined; //  gives current running server.
const  address: string | undefined; // gives host ip address.
const  listeningTo: string | undefined; // gives -> http://${host}:${port}/${base} -> http://localhost:3000/api

const app = mockServer.app;
const data = mockServer.data;
// const { db, injectors, middlewares, rewriters, config, store } = mockServer.data

const db = mockServer.db;
const middleware = mockServer.middleware;
const injectors = mockServer.injectors;
const rewriters = mockServer.rewriters;
const config = mockServer.config;
const store = mockServer.store;
const initialDb = mockServer.initialDb;

// Node Package exposes
const _ = MockServer._ // lodash.
const axios = MockServer.axios // axios.
const express = MockServer.express // express.
const chalk = MockServer.chalk // chalk.
const watcher = MockServer.watcher // chokidar.
const pathToRegexp = MockServer.pathToRegexp // pathToRegexp.
const nanoid = MockServer.nanoid // nanoid.
const ora = MockServer.ora // ora

const MockServer = require("@r35007/mock-server").default;
const mockServer = MockServer.Create();

mockServer.setData({ db, injectors, middlewares, rewriters, store, config });

//or

// Please follow the same following order of setting the data
// If merge param is true. it adds the data with the existing data.
mockServer.setConfig(config, { root, merge, log });
mockServer.setMiddlewares(middlewares, { root, merge, log });
mockServer.setInjectors(injectors, { root, merge, log });
mockServer.setRewriters(rewriters, { root, merge, log });
mockServer.setStore(store, { root, merge, log });
mockServer.setDb(Db, { root, merge, log, injectors, reverse, dbMode });

// Set to Defaults
mockserver.setDefaults(); // sets default db, injectors, middlewares, store, rewriters, config
mockserver.setDefaultData(); // sets default injectors, middlewares, store, config
mockserver.setDefaultDb(); // sets default db
mockserver.setDefaultInjectors(); // sets default injectors
mockserver.setDefaultMiddlewares(); // sets default middlewares
mockserver.setDefaultRewriters(); // sets default rewriters
mockserver.setDefaultStore(); // sets default store
mockserver.setDefaultConfig(); // sets default config

mockserver.clearServerAddress(); // sets current port, address, listeningTo, server to `undefined`
mockserver.setExpressApp(); // create a new express app to the MockServer instance.

const {
  MockServer,
  express, // express
  lodash, // lodash
  nanoid, // nanoid
  spinner, // ora
  pathToRegexp, // path-to-regexp
  chalk, // chalk
  axios, // axios
  watcher, // chokidar.
} = require("@r35007/mock-server");

const {
  getValidDb,
  getValidMiddlewares,
  getValidInjectors,
  getValidRewriters,
  getValidConfig,
  getValidStore,
  getValidRouteConfig,
} = require("@r35007/mock-server/dist/server/utils/validators");

const options = {
  reverse: true, // If true the db will be generated in reverse order
  dbMode: "fetch", // The direct route value will be set to fetch
};

const root = "./";

const db = getValidDb(
  "db.json", // db or HAR
  { injectors, root, reverse, dbMode, mockServer }
); // returns valid Db combined with the given injectors. Also helps to extract a db from HAR file. internally use getValidRouteConfig
const middleware = getValidMiddlewares(middlewares, { root, mockServer }); // returns a valid middleware along with the default middlewares
const injectors = getValidInjectors(injectors, { root, mockServer }); // returns a valid injectors. internally use getValidInjectorConfig
const rewriters = getValidRewriters(rewriters, { root, mockServer }); // returns a valid rewriters
const config = getValidConfig(config, { root, mockServer }); // returns a valid config combined with the default configs
const store = getValidStore(store, { root }); // returns a valid store
const routeConfig = getValidRouteConfig(route, routeConfig); // returns a valid routeconfig used by getValidDb
const injectorConfig = getValidInjectorConfig(route, routeConfig); // returns a valid injectorsConfig used by getValidInjectors
const route = getValidRoute(route); // splits route by comma and adds a slash ('/') prefix to the routes