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

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

const date = require('date-and-time')

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

const fs = require('fs')

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' })
  console.log('linked')

  // for (let i = 0; i < queueModels.length; i++) {
  //   queueModels[i].model.belongsTo(Users, { foreignKey: 'student' })
  // }
}

function fillCache () {
  fillUsers()
  fillRoles()
  fillQueuesAndCourses()
}

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

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

function fillQueuesAndCourses () {
  Queues.findAll({
    include: [
      { model: Users },
      { model: Courses }
    ],
    attributes: ['users1.name', 'student', 'task', 'location', 'comment', 'queueNo', 'enterTime', 'courses1.name', 'courses1.ID', 'courses1.open']
  }).then(res => {
    for (let queue of res) {
      // console.log('------this queue query',queue.student, queue.users1.name, queue.task, queue.location, queue.queueNo, queue.enterTime, queue.courses1.name, queue.courses1.ID)
      if (courses.some(e => e.ID === queue.courses1.ID)) {

      } else {
        courses.push(new Course({
          ID: queue.courses1.ID,
          name: queue.courses1.name,
          open: queue.courses1.dataValues.open === 1
        }))
      }

      // 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, // kanske inte behövs
        enterTime: queue.enterTime,
        receivingHelp: false
      }

      if (queues.some(e => e.ID === queue.courses1.ID)) {
        appendToQueue(queue.courses1.ID, queueItem)
      } else {
        queues.push(new Queue({
          ID: queue.courses1.ID,
          name: queue.courses1.name,
          queue: [queueItem]
        }))
      }
    }
  }).catch(error => {
    console.error(error)
    throw error
  })
}

function appendToQueue (ID, queueItem) {
  for (let i = 0; i < queues.length; i++) {
    if (queues[i].ID === ID) {
      queues[i].queue.push(queueItem)
      console.log(queues[i].queue)
    }
  }
}
// works
exports.queueLockSwitch = (ID) => {
  console.log('in  model: courseID is ', ID)
  let open = this.getCourse(ID).open

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

  this.getCourse(ID).open = !this.getCourse(ID).open
  // console.log('open',open)

  Courses.update(
    { open: open },
    { where: { ID: ID } }
  ).catch(err => console.error(err))
  // return getCourses();
  return this.getCourse(ID).open
}

// works
exports.deleteCourse = (ID) => {
  console.log('------ID-------', ID)
  courses.splice(this.getCourseIndex(ID), 1)

  Courses.destroy({
    where: {
      ID: ID
    }
  }).then(res => {

  })
}
// works
exports.getCourseIndex = (ID) => {
  for (var i = 0; i < courses.length; i++) {
    // console.log(courses[i], i)
    if (courses[i].ID === ID) {
      return i
    }
  }
  return null
}
// works
exports.getCourse = (ID) => {
  for (let course of courses) {
    if (course.ID === ID) {
      return course
    }
  }
  return null
}

// exports.getQueues = () => {
//   console.log('getting queues in getqueues')
//   var queues2 = new Map()
//   for (var i = 0; i < courses.length; i++) {
//     queues.set(courses[i].ID, queueTemplate)
//   };
//   return queues
// }

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

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

      } else {
        let currentCourse = this.getCourse(r.courseID)
        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
}

// används troligen inte§

// exports.getMyCourses = (user, role) => {
//   console.log('getting courses by ', user)
//   var list = []
//   // if role == 0: return the courses in which
//   // the student has enqueued
//   if (role == 0) {
//     this.getQueues().forEach((value, key, map) => {
//       for (var i = 0; i < value.length; i++) {
//         if (value[i].name === user) {
//           list.push(this.getCourse(key))
//           console.log('queue: ', key)
//         }
//       }
//     })
//   } else {
//     // else: return the courses the user has the requested access to
//     for (var i = 0; i < roles.length; i++) {
//       if (roles[i].name == user) {
//         if (roles[i].role <= role) {
//           list.push(this.getCourse(roles[i].course_ID))
//         }
//       }
//     }
//   }
//   console.log(list)
//   return list
// }
//
exports.getQueue = (courseID) => {
  return this.getQueueByCourseID(courseID)
}

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

// works
exports.check = (req) => {
  // req = JSON.parse(req)
  console.log('checking from model', req.username)

  for (var i = 0; i < users.length; i++) {
    console.log(users[i].email)

    if (users[i].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 if (users[i].password === req.password) {
        console.log('Logged in.')
        // return {
        //   courses: this.getCourses(),
        //   myCourses: this.getMyCourses(req.username, req.role),
        //   queues: this.getQueues()
        // }
        return true
      } else {
        console.log('Wrong password')
        return null
      }
    }

    console.log('User not found')
  }
  return null
}

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

// works
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
}

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

// wokrs
exports.removeQueueItem = (courseID, queueItemID) => {
  console.log('In model removeQueueItem, received: ', courseID, queueItemID)
  console.log('--------queues[0].queue[0]', queues[0].queue[0])
  for (let i = 0; i < queues.length; i++) {
    console.log('queues[i].ID', queues[i].ID, 'match', courseID)

    if (queues[i].ID === courseID) {
      console.log('courseID matchade!')
      console.log('queues[i].length:', queues[i].length)
      for (let j = 0; j < queues[i].queue.length; j++) {
        console.log('queues[i].queue[j].queueNo', queues[i].queue[j].queueNo, 'match', queueItemID)

        if (queues[i].queue[j].queueNo == queueItemID) { console.log('queueNo matchade!') }
        // console.log(queues[i].queue[j])
        console.log('before', queues[i].queue)
        queues[i].queue.splice(j, 1)
        console.log('afeter', queues[i].queue)

        Queues.destroy({
          where: { courseID: courseID, queueNo: queueItemID }
        })
        break
      }
    }
  }
}

// wroks
exports.createNewCourse = (courseObject) => {
  let errorMessage = ''
  let success = true
  let managers = courseObject.managers.split(',')
  for (let i = 0; i < managers.length; i++) {
    managers[i] = managers[i].trim()
  }
  console.log('Received managers: ', managers)
  let assistants = courseObject.assistants.split(',')
  for (let i = 0; i < assistants.length; i++) {
    assistants[i] = assistants[i].trim()
  }
  console.log('Received assistants: ', assistants)
  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)
  /*
     * We have now checked if the course is valID or not.
     */

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

    Courses.create({ ID: courseObject.courseID, name: courseObject.courseName, open: 0 }).catch(err => { console.error(err) })

    for (let asse of confirmedAssistants) {
      let ID = findIDofUser(asse)
      console.log('assID', ID)
      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) })
    }
  }

  return { success: true }
}

function findIndexOfAccount (name) {
  console.log('DENNA SKA FÖRSVINNA OCH BYTAS MOT model.findIDofUser(name)')
  return this.findIDofUser(name)
}

function findIDofUser (name) {
  for (let i = 0; i < users.length; i++) {
    if (name === users[i].name) {
      return users[i].ID
    }
  }
  return -1
}
// works
exports.addQueueItem = (req) => {
  console.log('in model, addQueueItem, received ', req)
  // req - queueObject{name queue_id request(help present) comment location receivingHelp(bool)} CourseID
  /*
     * TODO: find the right course using req.courseID
     */
  // find right queue
  for (let queue of queues) {
    console.log('-----', queue.ID, req.CourseID)
    if (queue.ID === req.CourseID) {
      let time = new Date() // date.format(new Date(), 'YYYY/MM/DD HH:mm:ss'),
      let studentID = findIDofUser(req.queueObject.name)
      let queueItem = {
        studentID: studentID,
        studentName: req.queueObject.name,
        task: req.queueObject.request,
        location: req.queueObject.location,
        comment: req.queueObject.comment,
        queueNo: req.queueObject.queue_id, // kanske inte behövs
        enterTime: time,
        receivingHelp: false
      }

      Queues.create({
        courseID: req.CourseID,
        student: studentID,
        task: req.queueObject.request,
        location: req.queueObject.location,
        comment: req.queueObject.comment,
        queueNo: req.queueObject.queue_id,
        enterTime: time
      }).catch(err => console.error(err))
      appendToQueue(queue.ID, queueItem)
      break
    }
  }
}
// works
exports.registerNewUser = (userObject) => {
  console.log('In model registerNewUser, received ', userObject)
  // let ID = 1

  for (let user of users) {
    if (user.name === userObject.username) {
      console.log('username already exists')
      return false
    }
  }

  Users.create({

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

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

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

    })
    )
    console.log(users)
  })
  return true
}