import * as Koa from 'koa'
import * as serve from 'koa-static'
import * as http from 'http'
import * as path from 'path'

const app = new Koa()

app.use(serve(path.join(__dirname, '')))

http.createServer(app.callback()).listen(3000, () => {
    console.log(`http server listening on port: 3000`)
})

import * as Koa from 'koa'
import * as serve from 'koa-static'
import { Server } from 'ws'
import SocketHandler from './socketHandler'

const app = new Koa();

app.use(serve('./public'));

const wss = new Server({server: app.listen(3000)});

new SocketHandler(wss);

console.log('application is running on port 3000');

    add: (app, middleware, options) => {
      app.use(
        webpackServeWaitpage(options, {
          template: fs.readFileSync(
            path.join(config.paths.gitRoot, 'webpack', 'config', 'waitpage.ejs'),
            'utf8'
          )
        })
      )

      app.use(mount('/node_modules', serve(config.paths.nodeModules)))

      app.use(
        mount('/currencies', serve(path.join(config.paths.vendor, 'game-currency-formats', 'src')))
      )

      // Make sure the usage of webpack-serve-waitpage will be before the following commands if exists
      middleware.webpack()
      middleware.content()

      app.use(router.routes())
    }

export function serveStatic(): Koa.Middleware {
    const middlewares: Array<Koa.Middleware> = [];
    const distPublicPath = path.resolve(__dirname, '../public');
    middlewares.push(mount('/dist/public', serve(distPublicPath)));
    middlewares.push(favicon(path.resolve(distPublicPath, 'images', 'icons', 'favicon.ico')));
    if (!isProdEnv) {
        const publicPath = path.resolve(__dirname, '../../public');
        middlewares.push(mount('/public', serve(publicPath)));
        const nodeModulesPath = path.resolve(__dirname, '../../node_modules');
        middlewares.push(mount('/node_modules', serve(nodeModulesPath)));
    }
    middlewares.push(async (ctx: Koa.Context, next: () => Promise<any>) => {
        const url = ctx.originalUrl;
        if (url.substr(0, 6) === '/dist/'
            || url.substr(0, 14) === '/node_modules/'
            || url.substr(0, 8) === '/public/') {
            ctx.status = 404;
        } else {
            await next();
        }
    });
    return compose(middlewares);
}

	run() {
		this.app_.init(this);
		this.diposable_ = new CompositeDisposable();
		this.sessionManager_ = new SessionManager(() => { 
			this.app_.createSessionData() });
		this.connections_ = [];

		const koaApp = new Koa();
		koaApp.use(this.sessionManager_.asKoaMiddleware());
		koaApp.use(koaStatic("static", {}));
		const port = 3003;
		console.log(`start listen at ${port}`);

		const httpServer = http.createServer(koaApp.callback());

		const webSocketServer = new WebSocketServer({
			httpServer: httpServer 
			});
		webSocketServer.on("request", (request: WebSocketRequest) => {
			let sid: string = null;
			request.cookies.forEach((cookie) => {
				if (cookie.name == "sid") {
					sid = cookie.value;
					return;
				}
			});

			if (sid == null) {
				request.reject(403, "no sid");
				return;
			}

			let session = this.sessionManager_.openSession(sid);
			if (session == null) {
				request.reject(403, "invalid session id");
				return;
			}
			
			const socket = new SocketImpl(request.accept(null, null));
			this.createConnection(socket, sid);
		});

		httpServer.listen(port);
	}

export default function middleware(context: Koa) {
    const ctrlRouter = new WebApiRouter();
    return Compose(
        [
            asyncInit(),
            errorHandle(),
            KoaStatic(Path.join(__dirname, '../public'), { gzip: true }),
            Session({
                cookie: {
                    maxAge: SessionService.maxAge
                }
            }),
            sessionHandle(),
            Bodyparser({ jsonLimit: '50mb' }),
            ctrlRouter.router('../build/controllers', 'api'),
            routeFailed(),
        ]
    );
}

import * as convert from 'koa-convert'
import * as webpack from 'webpack'
import * as historyApiFallback from 'koa-connect-history-api-fallback'
import * as path from 'path'
import * as fs from 'fs-extra'
import * as _debug from 'debug'
import configs from '../configs'
import webpackDevMiddleware from './middleware/webpack-dev'
import webpackHMRMiddleware from './middleware/webpack-hmr'
import webpackConfig from './webpack.client'

const debug = _debug('app:server')
const app = new Koa()
const __DEV__ = configs.env === 'development'

app.use(convert(historyApiFallback({
  verbose: false,
})))

if (__DEV__) {
  // Enable webpack-dev and webpack-hot middleware
  const compiler = webpack(webpackConfig as any)
  const { publicPath } = webpackConfig.output
  app.use(webpackDevMiddleware(compiler, publicPath))
  app.use(webpackHMRMiddleware(compiler))
} else {
  app.use(convert(KoaStatic(configs.outDir)))
}

export default app

        neq: function fnb(this: any, lvalue: any, rvalue: any, options: any) {
          if (arguments.length < 3) {
            throw new Error("Handlebars Helper equal needs 2 parameters");
          }
          if (lvalue !== rvalue) {
            return options.fn(this);
          } else {
            return options.inverse(this);
          }
        },
      },
    },
  })
);
// TODO: logger
app.use(bodyParser());
app.use(
  session({
    store: new sessionStore(dbPath),
  })
);
app.use(
  mount("/js", serve(`${__dirname}/../node_modules/material-design-lite/dist`))
);
app.use(
  mount("/css", serve(`${__dirname}/../node_modules/material-design-lite/dist`))
);
app.use(router.routes()).use(router.allowedMethods());

export default app;

    md.remove(ctx.request.body.id);
    ctx.body = true;
});
router.post('/edit', (ctx, next) => {
    ctx.body = md.getFile(ctx.request.body.id);
});
router.post('/updateCont', (ctx, next) => {
    md.setFile(ctx.request.body.id, ctx.request.body.cont);
    ctx.body = true;
})
router.post('/updateTitle', (ctx, next) => {
    const
        id = ctx.request.body.id,
        title = ctx.request.body.title;
    ctx.body = md.setTitle(id, title);
});
koa
    .use(body({}))
    .use(router.routes())
    .use(router.allowedMethods())
    .use(Static(__dirname + '/view'))
    .use(Static(path.join(__dirname ,'../../')));

export class Admin {
    constructor(port) {
        koa.listen(port, (e) => {
            console.log(`Admin is run. port:${port}`);
            // open('http://localhost:' + port);
        });
    }
}

  if (ctx.path === '/favicon.ico') return
  ctx.session.views = (ctx.session.views || 0) + 1
  let app: any = ctx.app
  if (ctx.session.fullname) app.counter.users[ctx.session.fullname] = true
})
app.use(cors({
  credentials: true
}))
app.use(async(ctx, next) => {
  await next()
  if (typeof ctx.body === 'object' && ctx.body.data !== undefined) {
    ctx.type = 'json'
    // ctx.body.path = ctx.path
    ctx.body = JSON.stringify(ctx.body, undefined, 2)
  }
})
app.use(async(ctx, next) => {
  await next()
  if (ctx.request.query.callback) {
    let body = typeof ctx.body === 'object' ? JSON.stringify(ctx.body, undefined, 2) : ctx.body
    ctx.body = ctx.request.query.callback + '(' + body + ')'
    ctx.type = 'application/x-javascript'
  }
})

app.use(serve('public'))
app.use(serve('test'))
app.use(body())
app.use(router.routes())

export default app