/**
 * @file Exports a function that returns an Express router instance for
 *       defining various request handlers.
 */
'use strict';

// Required Node.js modules.
const bcrypt  = require('bcrypt');
const express = require('express');

// Required project modules.
const auth     = require('./auth.js');
const debug    = require('../utils/debug.js');
const question = require('../utils/question.js');
const rooms    = require('../utils/rooms.js');
const sequence = require('../utils/sequence.js');
const shuffle  = require('../utils/shuffle.js');

// Alias object prototypes.
const Question    = question.Question;
const RoomManager = rooms.RoomManager;

// Define local constants.
const SALT_ROUNDS = 10;


/**
 * Creates and returns an Express-compatible router function.
 * @param  {EventEmitter} app
 * @return {Function}
 */
module.exports = function(app) {

  let router = express.Router();


  // GET http://localhost:3000
  router.get('/', (request, response) => {
    console.log('index');
    request.db.transact([
      { sql: 'SELECT COUNT(*) FROM student;' },
      { sql: 'SELECT * FROM student LIMIT 1;' },
      { sql: 'SELECT * FROM student WHERE username = $1::text;', params: [ 'connor' ] }
    ], (error, results) => {
      if (error) {
        return console.log(error);
      }
      console.log(results[0].rows);
    });
    response.render('index');
  });


  // GET http://localhost:3000/signin
  router.get('/signin', (request, response) => {
    response.render('signin', {
      pageTitle: 'Sign In'
    });
  });


  // GET http://localhost:3000/quizzes-available
  router.get('/quizzes-available', auth, (request, response) => {
    let sql = 'SELECT q.id, q.title FROM student_in_section s INNER JOIN quiz q ON s.section_id = q.section_id WHERE s.student_id = $1::int;',
        params = [ request.session.user.id ];

    request.db.query(sql, params, (error, results) => {
      if (error) {
        return console.log(error);
      }

      response.render('quizzes-available', {
        pageTitle: 'Available Quizzes',
        groupId:   request.session.user.student_group_id,
        quizzes:   results.rows
      });
    });
  });


  // POST http://localhost:3000/signin
  router.post('/signin', (request, response) => {
    let username = request.body.username,
        password = request.body.password;

    let sql    = 'SELECT id, first_name, last_name, password, student_group_id FROM student WHERE username = $1::text LIMIT 1;',
        params = [ username ];

    request.db.query(sql, params, (error, results) => {
      if (error) {
        return console.log(error);
      }

      if (results.rows.length === 0) {
        return response.render('signin', {
          pageTitle: 'Sign In',
          error: 'Username/password mismatch.'
        });
      }

      bcrypt.compare(password, results.rows[0].password).then(match => {
        if (match === true) {
          request.session.user = results.rows[0];
          return response.redirect('quizzes-available');
        }

        response.render('signin', {
          pageTitle: 'Sign In',
          error: 'Username/password mismatch.'
        });
      });
    });
  });


  // GET http://localhost:3000/register
  router.get('/register', (request, response) => {
    response.render('register', {
      pageTitle: 'Sign Up'
    });
  });


  // POST http://localhost:3000/register
  router.post('/register', (request, response) => {
    let username = request.body.username,
        password = request.body.password,
        fName    = request.body.fName,
        lName    = request.body.lName,
        iNum     = request.body.iNum;

    bcrypt.hash(password, SALT_ROUNDS, (error, hash) => {
      if (error){
        return console.log(error);
      }

      let sql    = 'INSERT INTO student(username, password, first_name, last_name, i_number) VALUES ($1::text, $2::text, $3::text, $4::text, $5::text);',
          params = [ username, hash, fName, lName, iNum ];

      request.db.query(sql, params, (error, results) => {
        if (error) {
          return console.log(error);
        }

        response.redirect('/signin');
      });
    });
  });


  /**
   * Keeps track of which client websocket connections belong to which
   * user group for the application /group/:gid endpoint.
   * @type {RoomManager}
   */
  let groups = new RoomManager;


  // GET http://localhost:3000/group/:group_id/quiz/:quiz_id
  router.get('/group/:group_id/quiz/:quiz_id', auth, (request, response, next) => {
    if (request.session.user.student_group_id === Number(request.params.group_id)) {
      return next();
    }
    response.redirect('/quizzes-available');
  }, (request, response) => {
    request.ws.once('connection', socket => {
      let key   = `${request.params.group_id}:${request.params.quiz_id}`;
      let group = groups.add(key).add(socket).broadcast({
        type:       'joined',
        id:         request.session.user.id,
        first_name: request.session.user.first_name
      });

      socket.send(JSON.stringify({
        timestamp:  Math.floor(new Date() / 1000),
        type:       'identification',
        id:         request.session.user.id,
        first_name: request.session.user.first_name
      }));

      new Promise((resolve, reject) => {
        if (group.questions !== undefined && group.questions.length) {
          return resolve(group.questions);
        }

        let sql = 'SELECT q.id AS question_id, q.content AS question_content, qa.id AS answer_id, qa.content AS answer_content FROM question q INNER JOIN question_answer qa ON qa.question_id = q.id WHERE q.quiz_id = $1::int ORDER BY q.id, qa.id;',
            params = [ request.params.quiz_id ];

        request.db.query(sql, params).then(result => {
          let questions = [];

          while(result.rows.length) {
            let answers  = shuffle(result.rows.splice(0, 4)),
                question = new Question(answers[0]['question_id'], answers[0]['question_content']);

            for (const answer of answers) {
              question.addAnswer(answer['answer_id'], answer['answer_content']);
            }
            questions.push(question);
          }

          group.questions = questions;
          resolve(group.questions);
        });
      }).then(questions => {
        sequence(questions, (results, question, next) => {
          if (group.currentQuestion === undefined) {
            group.currentQuestion = 0;
            group.broadcast(group.questions[group.currentQuestion].toJSON());
          }

          function response(data) {
            let parsed = JSON.parse(data);

            if (!parsed.type) {
              return;
            }

            // if type === 'appeal'

            if (parsed.type !== 'answerConfirm') {
              return group.broadcast(parsed);
            }

            let sql    = 'SELECT correct FROM question_answer WHERE id = $1::int LIMIT 1;',
                params = [ parsed['answer_id'] ];

            request.db.query(sql, params, (error, result) => {
              if (error) {
                return console.log(error);
              }

            let sql    = 'INSERT INTO group_answer(student_group_id,question_answer_id) VALUES ($1::int, $2::int);',
                params = [ request.params.group_id, parsed['answer_id'] ];

            request.db.query(sql,params,function(){


            if (result.rows[0].correct === true) {
                socket.removeEventListener('message', response);
                group.broadcast({
                  type:       'answerCorrect',
                  answer_id : Number(parsed['answer_id'])
                });

                setTimeout(() => {
                  if (++group.currentQuestion < group.questions.length) {
                    group.broadcast(group.questions[group.currentQuestion].toJSON());
                  }
                  next();
                }, 5000);
              } else {
                group.broadcast({
                  type:      'answerIncorrect',
                  answer_id : Number(parsed['answer_id'])
                });
              }
            });

            });
          };

          socket.on('message', response);
        }, () => {

            let sql = 'INSERT INTO grade (student_group_id, quiz_id, score) SELECT t.student_group_id AS student_group_id,t.quiz_id AS quiz_id, SUM(t.answers) AS total_score FROM (SELECT ga.student_group_id AS student_group_id,qz.id AS quiz_id, CASE WHEN COUNT(qa.id) = 1 THEN 4 WHEN COUNT(qa.id) = 2 THEN 2 WHEN COUNT(qa.id) = 3 THEN 1 WHEN COUNT(qa.id) = 4 THEN 0 END AS answers FROM group_answer ga INNER JOIN question_answer qa ON ga.question_answer_id = qa.id INNER JOIN question qn ON qa.question_id = qn.id INNER JOIN quiz qz ON qn.quiz_id = qz.id WHERE ga.student_group_id = $1::int AND qz.id = $2::int GROUP BY ga.student_group_id, qz.id, qa.question_id) AS t GROUP BY t.student_group_id, t.quiz_id;',
                params = [request.params.group_id, request.params.quiz_id];

            request.db.query(sql,params,function(){
               group.broadcast({
                type:    'notice',
                message: 'QUIZ OVER'
                });

                response.redirect('/');
          });
        });
      });

      socket.on('close', error => {
        group.remove(socket).broadcast({
          type: 'left',
          id:   request.session.user.id
        });
      });
    });

    response.render('quiz');
  });

  return router;
};