/* jslint node: true */
'use strict'

const sequelizeInit = require('./sequelize.js')
const sequelize = sequelizeInit.initSequelize()
const bcrypt = require('bcrypt')

const User = require('./models/userModel.js')
const Role = require('./models/roleModel.js')
const Course = require('./models/courseModel.js')
const Queue = require('./models/queueModel.js')

var Users
var Roles
var StudentStatistics
var CourseStatistics
var Courses
var Queues

const courses = []
const users = []
const roles = []
const queues = []

// creating sequelize models
exports.initDatabase = () => {
  // sequelizeInit.autoSequelize()
  initConstants()
}
function initConstants () {
  Users = sequelize.import('./seq_models/users1.js')
  Roles = sequelize.import('./seq_models/roles1.js')
  StudentStatistics = sequelize.import('./seq_models/studentStatistics1.js')
  CourseStatistics = sequelize.import('./seq_models/courseStatistics1.js')
  Courses = sequelize.import('./seq_models/courses1.js')
  Queues = sequelize.import('./seq_models/queues1.js')

  linkModels()
  fillCache()
}

function linkModels () {
  Queues.belongsTo(Users, { foreignKey: 'student' })
  Queues.belongsTo(Courses, { foreignKey: 'courseID' })
  Roles.belongsTo(Users, { foreignKey: 'ID' })
  Roles.belongsTo(Courses, { foreignKey: 'courseID' })
  console.log('linked')
}

function fillCache () {
  fillUsers()
  fillRoles()
  fillCourses()
  fillQueues()
}

// fill User fillCache
function fillUsers () {
  Users.findAll().then(res => {
    for (let user of res) {
      users.push(new User({
        ID: user.ID,
        name: user.name,
        email: user.email,
        password: user.password
      })
      )
    }
  })
}

// fill roles cache
function fillRoles () {
  Roles.findAll({
    include: Users
  }).then(res => {
    for (let role of res) {
      roles.push(new Role(
        {
          ID: role.ID,
          courseID: role.courseID,
          role: role.role

        })
      )
    }
  })
}

function fillCourses () {
  Courses.findAll().then(res => {
    for (let course of res) {
      courses.push(new Course({
        ID: course.ID,
        name: course.name,
        open: course.dataValues.open === 1
      }))

      queues.push(new Queue({
        ID: course.ID,
        name: course.name,
        queue: [],
        open: false
      }))
    }
  })
}

function fillQueues () {
  Queues.findAll({
    include: [
      { model: Users },
      { model: Courses }
    ]

  }).then(res => {
    for (let queue of res) {
      // adds students in queue to given course
      var queueItem = {
        studentID: queue.student,
        studentName: queue.users1.name,
        task: queue.task,
        location: queue.location,
        comment: queue.comment,
        queueNo: queue.queueNo,
        enterTime: new Date(queue.enterTime), // ändrad
        receivingHelp: false
      }

      appendToQueue(queue.courses1.ID, queueItem)
    }
  }).catch(error => {
    console.error(error)
  })
}

function appendToQueue (ID, queueItem) {
  for (let i = 0; i < queues.length; i++) {
    if (queues[i].ID === ID) {
      queues[i].queue.push(queueItem)
    }
  }
}

exports.queueLockSwitch = (ID) => {
  let open = this.getCourse(ID).open

  if (open === false) {
    open = 1
  } else {
    open = 0
  }

  this.getCourse(ID).open = !this.getCourse(ID).open

  Courses.update(
    { open: open },
    { where: { ID: ID } }
  ).catch(err => console.error(err))

  return this.getCourse(ID).open
}

exports.deleteCourse = (ID) => {
  courses.splice(this.getCourseIndex(ID), 1)

  Courses.destroy({
    where: {
      ID: ID
    }
  }).catch(err => { console.error(err) })
}

exports.getCourseIndex = (ID) => {
  for (var i = 0; i < courses.length; i++) {
    if (courses[i].ID === ID) {
      return i
    }
  }
  return null
}

exports.getCourse = (ID) => {
  for (let course of courses) {
    if (course.ID === ID) {
      return course
    }
  }
  return null
}

exports.getCoursesBelongingTo = (email) => {
  console.log('In Model: getcoursesbelonging to: ', email)
  let myCourses = []
  let userID = this.findIDfromEmail(email)

  for (let r of roles) {
    if (userID === r.ID) {
      if (myCourses.some(e => e.courseID === r.courseID)) {

      } else {
        let currentCourse = this.getCourse(r.courseID)
        console.log('currentCourse in model is ', this.getCourse(r.courseID))

        if (currentCourse != null) {
          myCourses.push({
            CourseID: currentCourse.ID,
            key: currentCourse.name,
            open: currentCourse.open,
            role: r.role
          })
        }
      }
    }
  }

  return myCourses
}

exports.getQueueByCourseID = (ID) => {
  for (let q of queues) {
    if (q.ID === ID) {
      return q
    }
  }
  return null
}

exports.getQueue = (courseID) => {
  return this.getQueueByCourseID(courseID)
}

exports.getCourses = () => {
  return courses
}

exports.check = (req, emit) => {
  console.log('checking from model', req.username)

  for (let user of users) {
    if (user.email === req.username) {
      console.log('User found')

      let userID = this.findIDfromEmail(req.username)

      if (this.getHighestRole(userID) < req.role) {
        console.log('Too low authority')
        return null
      } else {
        verifyPassword(req.password, user.password, emit)
      }
    }
  }
}

exports.findIDfromEmail = (email) => {
  console.log(email)
  for (let user of users) {
    if (user.email === email) {
      return user.ID
    }
  }
}

exports.getHighestRole = (userID) => {
  let highest = 0
  for (let role of roles) {
    if (role.ID === userID && role.role > highest) {
      highest = role.role
      if (highest === 2) {
        return highest
      }
    }
  }

  return highest
}

exports.updateQueueItem = (courseID, queueItemID) => {
  console.log('in model updateQueueItem: ', courseID, queueItemID)
  for (let queue of queues) {
    if (queue.ID === courseID) {
      for (let student of queue.queue) {
        if (student.queueNo === queueItemID) {
          student.receivingHelp = !student.receivingHelp
          incrementTimesHelped(student.studentID)
          break
        }
      }
    }
  }
}

exports.removeQueueItem = (courseID, queueItemID, studentID, callback) => {
  for (let i = 0; i < queues.length; i++) {
    if (queues[i].ID === courseID) {
      for (let j = 0; j < queues[i].queue.length; j++) {
        if (queues[i].queue[j].queueNo === queueItemID) {
          incrementTimeSpentInQueues(queues[i].queue[j].studentID, queues[i].ID, queues[i].queue[j].enterTime)
          queues[i].queue.splice(j, 1)

          Queues.destroy({
            where: { courseID: courseID, student: studentID }
          }).catch(err => { console.error(err) })
          break
        }
      }
    }
  }
  callback(true)
}

exports.createNewCourse = (courseObject, callback) => {
  let errorMessage = ''
  let success = true
  let managers = courseObject.managers.split(',')
  for (let i = 0; i < managers.length; i++) {
    managers[i] = managers[i].trim()
  }

  let assistants = courseObject.assistants.split(',')
  for (let i = 0; i < assistants.length; i++) {
    assistants[i] = assistants[i].trim()
  }

  if (assistants.length === 1 && assistants[0] === '') {
    assistants = []
    console.log('Assistants is empty.')
  }
  let confirmedAssistants = []
  let confirmedManagers = []

  for (let i = 0; i < users.length; i++) {
    let managerIndex = managers.indexOf(users[i].name)
    let assistantIndex = assistants.indexOf(users[i].name)

    console.log('usersName:', users[i].name)
    if (managerIndex !== -1) {
      confirmedManagers.push(users[i].name)
      managers.splice(managerIndex, 1)
    }
    if (assistantIndex !== -1) {
      confirmedAssistants.push(users[i].name)
      assistants.splice(assistantIndex)
    }
  }

  for (let i = 0; i < courses.length; i++) {
    if (courses[i].name === courseObject.courseName) {
      errorMessage += '\nCourse with name ' + courseObject.courseName + ' already exists.'
      success = false
    }
    if (courses[i].ID === courseObject.courseID) {
      errorMessage += '\nCourse with ID ' + courseObject.courseID + ' already exists.'
      success = false
    }
  }

  if (assistants.length > 0) {
    success = false
    errorMessage += '\nThe following assistants were not found: ' + assistants
  }

  if (managers.length > 0) {
    success = false
    errorMessage += '\nThe following managers were not found: ' + managers
  }
  console.log(errorMessage)
  console.log('Success? ', success)

  if (success) {
    courses.push(
      {
        name: courseObject.courseName,
        ID: courseObject.courseID,
        open: false
      }
    )

    Courses.create({
      ID: courseObject.courseID,
      name: courseObject.courseName,
      open: 0
    }).then(res => {
      CourseStatistics.create({
        courseID: res.ID,
        totTimeSpentInQueue: new Date('1000-01-01T00:00:00Z')
      })
    }).catch(err => { console.error(err) })
      .catch(err => { console.error(err) })

    for (let asse of confirmedAssistants) {
      let ID = findIDofUser(asse)

      roles.push({
        ID: ID,
        courseID: courseObject.courseID,
        role: 1
      })

      Roles.create({
        ID: ID,
        courseID: courseObject.courseID,
        role: 1 }).catch(err => { console.error(err) })
    }

    for (let manager of confirmedManagers) {
      let ID = findIDofUser(manager)
      roles.push({
        ID: ID,
        courseID: courseObject.courseID,
        role: 1
      })

      Roles.create({
        ID: ID,
        courseID: courseObject.courseID,
        role: 2
      }).catch(err => { console.error(err) })
    }
  }

  callback({ success: success, err: errorMessage })
}

exports.sortQueueByTime = (courseID) => {
  let q = this.getQueueByCourseID(courseID)
  let sortedQueue = q.queue
  let result = q.queue.sort(function (a, b) {
    new Date(a.time) - new Date(b.time)
  })
}

function findIDofUser (name) {
  for (let i = 0; i < users.length; i++) {
    if (name === users[i].name) {
      return users[i].ID
    }
  }
  return -1
}

exports.addQueueItem = (req, callback) => {
  console.log('in model, addQueueItem, received ', req)

  // find right queue
  for (let queue of queues) {
    if (queue.ID === req.CourseID) {
      let time = new Date()

      let studentID = req.queueObject.studentID
      console.log(studentID)

      Queues.create({
        courseID: req.CourseID,
        student: studentID,
        task: req.queueObject.request,
        location: req.queueObject.location,
        comment: req.queueObject.comment,
        queueNo: null,
        enterTime: time
      }).then(res => {
        let queueItem = {
          studentID: studentID,
          studentName: req.queueObject.name,
          task: res.task,
          location: res.location,
          comment: res.comment,
          queueNo: res.queueNo,
          enterTime: res.enterTime,
          receivingHelp: false
        }
        appendToQueue(queue.ID, queueItem)
        callback({ success: true, queueObject: queueItem })
        incrementTimesQueued(res.student, res.courseID)
      }).catch(err => console.error(err))
      break
    }
  }
}

exports.registerNewUser = (userObject, emit) => {
  checkAccounts(userObject.username, (success) => {
    if (success) {
      createPasswordHash(userObject.password, userObject.username.length, (hashPassword) => {
        Users.create({

          ID: NaN,
          name: userObject.username,
          email: userObject.email,
          password: hashPassword

        }).then(res => {
          users.push(new User({

            ID: res.ID,
            name: res.name,
            email: res.users1.email,
            password: res.password

          })
          )
          StudentStatistics.create({
            ID: res.ID,
            totTimeSpentInQueue: new Date('1000-01-01T00:00:00Z')
          })
        })

        console.log('Registered new user', users)
        emit('Your account is successfully registered')
      })
    } else {
      emit('Failure to register user: Username already taken')
    }
  })
}

function checkAccounts (username, cb) {
  let success = true

  for (let account of users) {
    if (account != null) {
      if (account.name === username) {
        console.log('username already exists')
        success = false
      }
    }
  }
  console.log('username available')
  cb(success)
}

function createPasswordHash (plain, saltRound, store) {
  bcrypt.genSalt(saltRound).then(salt => {
    return bcrypt.hash(plain, salt)
  }).then(hash => {
    store(hash)
  }).catch(err => { console.error(err) })
}

function verifyPassword (test, hash, callback) {
  bcrypt.compare(test, hash).then(res => {
    console.log('verified:', res)
    callback(res)
  }).catch(err => { console.error(err) })
}

exports.editCourse = (request, callback) => {
  let errorMessage = ''
  let success = true

  let courseID = request.CourseID

  if (this.getCourse(courseID) === null) {
    success = false
    errorMessage = 'Course with id ' + courseID + ' does not exist.'
  }

  let assistants = request.assistants.split(',')
  let managers = request.managers.split(',')
  for (let i = 0; i < managers.length; i++) {
    managers[i] = managers[i].trim()
  }
  for (let i = 0; i < assistants.length; i++) {
    assistants[i] = assistants[i].trim()
  }

  if (managers.length === 1 && managers[0] === '') {
    managers = []
    success = false
    errorMessage += '\nTried removing all managers. Each course needs a manager.'
  }
  if (assistants.length === 1 && assistants[0] === '') {
    assistants = []
  }

  console.log('received managers: ', managers)
  console.log('received assistants: ', assistants)

  if (assistants.length === 1 && assistants[0] === '') {
    assistants = []
    console.log('Assistants is empty.')
  }
  let confirmedAssistants = []
  let confirmedManagers = []

  for (let i = 0; i < users.length; i++) {
    let managerIndex = managers.indexOf(users[i].email)
    let assistantIndex = assistants.indexOf(users[i].email)

    console.log('userEmail:', users[i].email)
    if (managerIndex !== -1) {
      confirmedManagers.push(users[i].email)
      managers.splice(managerIndex, 1)
    }
    if (assistantIndex !== -1) {
      console.log('lägger till asse')
      confirmedAssistants.push(users[i].email)
      assistants.splice(assistantIndex, 1)
    }
  }

  if (assistants.length > 0) {
    success = false
    errorMessage += '\nThe following assistants were not found: ' + assistants
  }

  if (managers.length > 0) {
    success = false
    errorMessage += '\nThe following managers were not found: ' + managers
  }
  console.log(confirmedManagers, confirmedAssistants)

  console.log(errorMessage)
  console.log('Success? ', success)
  let resultObject = {
    success: success,
    err: errorMessage
  }
  callback(resultObject)

  if (success) {
    let rolesToCreate = []
    for (let asse of confirmedAssistants) {
      rolesToCreate.push({
        ID: this.findIDfromEmail(asse),
        role: 1
      })
    }

    for (let mngr of confirmedManagers) {
      rolesToCreate.push({
        ID: this.findIDfromEmail(mngr),
        role: 2
      })
    }
    console.log(rolesToCreate)

    Roles.destroy({ where: { courseID: request.CourseID } }).then(() => {
      for (let role of rolesToCreate) {
        Roles.create({
          ID: role.ID,
          courseID: request.CourseID,
          role: role.role
        }).catch(err => { console.error(err) })
      }
    }).catch(err => { console.error(err) })
  }
}

exports.getUserInfoByEmail = (email, callback) => {
  for (let user of users) {
    if (email.trim() === user.email) {
      console.log('found user!', user)
      let userObject = {
        ID: user.ID,
        name: user.name,
        email: user.email
      }
      callback(userObject)
    }
  }
}

exports.checkIfUserInQueue = (courseID, studentID) => {
  console.log('check if user in queue in model: ', courseID, studentID)
  // let queue = this.getQueueByCourseID(courseID).queue
  let queue = this.getQueueByCourseID(courseID).queue
  console.log('Checking still: ', queue)
  for (let qItem of queue) {
    console.log(qItem.studentID, studentID)

    if (qItem.studentID === studentID) {
      console.log('in model checkIfUserInQueue: returning true')
      return true
    }
  }
  console.log('in model checkIfUserInQueue: returning false')
  return false
}

function incrementTimesQueued (studentID, courseID) {
  console.log('-----incrementTimesQueued')
  StudentStatistics.findOne(
    { where: { ID: studentID } }

  ).then(res => {
    StudentStatistics.update(
      { noTimesQueued: res.noTimesQueued + 1 },
      { where: { ID: studentID } }
    ).catch(err => { console.error(err) })
  })

  CourseStatistics.findOne(
    { where: { courseID: courseID },
      attributes: ['courseID', 'totalQueued']
    }

  ).then(res => {
    CourseStatistics.update(
      { totalQueued: res.totalQueued + 1 },
      { where: { courseID: courseID } }
    ).catch(err => { console.error(err) })
  })
}

function incrementTimesHelped (studentID) {
  StudentStatistics.findOne(
    { where: { ID: studentID } }

  ).then(res => {
    StudentStatistics.update(
      { noTimesHelpRecieved: res.noTimesHelpRecieved + 1 },
      { where: { ID: studentID } }
    ).catch(err => { console.error(err) })
  })
}

function incrementTimeSpentInQueues (studentID, courseID, enterTime) {
  console.log('----in timeIncrement')
  let now = new Date()

  StudentStatistics.findOne(
    { where: { ID: studentID } }

  ).then(res => {
    console.log('STUDENT old time in queue', res.totTimeSpentInQueue)
    res.totTimeSpentInQueue.setMilliseconds((now - enterTime))
    console.log('STUDENT new time in queue', res.totTimeSpentInQueue)

    StudentStatistics.update(
      { totTimeSpentInQueue: res.totTimeSpentInQueue },
      { where: { ID: studentID } }
    ).catch(err => { console.error(err) })
  }).catch(err => { console.error(err) })

  CourseStatistics.findOne(
    {
      where: { courseID: courseID },
      attributes: ['TotalQueueTime']
    }
  ).then(res => {
    res.TotalQueueTime.setMilliseconds((now - enterTime))

    CourseStatistics.update(
      { TotalQueueTime: res.TotalQueueTime },
      { where: { courseID: courseID } }
    )
  })
}
exports.addStudentToStatistics = (i) => {
  StudentStatistics.create({
    ID: i
  })
}

exports.addRecievedHelp = (studentID) => {
  StudentStatistics.findOne({
    where: { ID: studentID }
  }).then(res => {
    StudentStatistics.update(
      { noTimesHelpRecieved: res.noTimesHelpRecieved + 1 }
    )
  })
}
exports.getStudentStatistics = (studentID) => {
  StudentStatistics.findOne({
    where: { ID: studentID }
  }).then(res => {
    let avgTime = convertTime(((res.totTimeSpentInQueue.getTime() - (new Date('1000-01-01T00:00:00Z')).getTime()) / (res.noTimesQueued)))

    let stats = new Map()
    stats.set('totQueued', res.noTimesQueued)
    stats.set('noTimesHelpRecieved', res.noTimesHelpRecieved)
    stats.set('avgTime', avgTime)

    return stats
  })
}

exports.getCourseStatistics = (courseID) => {
  CourseStatistics.findOne({
    where: { courseID: courseID }
  }).then(res => {
    let avgTime = convertTime(((res.TotalQueueTime.getTime() - (new Date('1000-01-01T00:00:00Z')).getTime()) / (res.totalQueued)))

    let stats = new Map()
    stats.set('totQueued', res.totalQueued)
    stats.set('avgTime', avgTime)

    return stats
  })
}

function convertTime (milliseconds) {
  var h, m, s
  s = Math.floor(milliseconds / 1000)
  m = Math.floor(s / 60)
  s = s % 60
  h = Math.floor(m / 60)
  m = m % 60

  console.log('STUDENT AVGTIME', [h, m, s])
  return [h, m, s]
}