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

// logged in already?
// const accounts = [
//   { name: 'jeannie', password: '1', role: 0, ID: 21 },
//   { name: 'alex', password: '1', role: 2, ID: 22 },
//   { name: 'gustav', password: '1', role: 2, ID: 23 },
//   { name: 'j', password: 'a', role: 0, ID: 24 },
//   { name: 'e', password: 'b', role: 0, ID: 25 }
// ]
//
// // ID should be autoincremented, open should be false as default
//
// const courses = [
//   { key: 'ADK', ID: 1, open: true },
//   { key: 'IntProg', ID: 2, open: true },
//   { key: 'Maskin', ID: 3, open: true },
//   { key: 'Tilda', ID: 4, open: false },
//   { key: 'Prutten', ID: 5, open: false },
//   { key: 'Språktek', ID: 6, open: false },
//   { key: 'MachineLearning', ID: 7, open: false },
//   { key: 'DeepLearning', ID: 8, open: false }
// ]
//
// var courseMap = new Map()
// for (var i = 0; i < courses.length; i++) {
//   courseMap.set(courses[i].ID, courses[i])
// }
//
// var roles = [
//   { course_ID: 1, name: 'jeannie', teacher_ID: 21, role: 2 },
//   { course_ID: 1, name: 'alex', teacher_ID: 22, role: 1 },
//   { course_ID: 1, name: 'gustav', teacher_ID: 22, role: 1 },
//   { course_ID: 2, name: 'alex', teacher_ID: 22, role: 2 },
//   { course_ID: 2, name: 'alex', teacher_ID: 23, role: 1 },
//   { course_ID: 3, name: 'alex', teacher_ID: 23, role: 2 },
//   { course_ID: 4, name: 'alex', teacher_ID: 23, role: 1 },
//   { course_ID: 5, name: 'alex', teacher_ID: 25, role: 1 },
//   { course_ID: 6, name: 'alex', teacher_ID: 24, role: 2 },
//   { course_ID: 7, name: 'alex', teacher_ID: 22, role: 2 },
//   { course_ID: 8, name: 'alex', teacher_ID: 21, role: 1 }
// ]
//
// // Queue ID should be given by the database automatically in
// // ascending order.
// var queueTemplate = [
//   {
//     name: 'magdalena',
//     queue_ID: 1,
//     request: 'help',
//     comment: 'help lab 2',
//     location: 'red 02',
//     receivingHelp: false
//   },
//   {
//     name: 'alex',
//     queue_ID: 2,
//     request: 'present',
//     comment: 'present lab 24',
//     location: 'magenta 04',
//     receivingHelp: false
//   },
//   {
//     name: 'jeannie',
//     queue_ID: 3,
//     request: 'present',
//     comment: 'presenting all the labs',
//     location: 'yellow 23',
//     receivingHelp: true
//   },
//   {
//     name: 'alexander',
//     request: 'present',
//     comment: 'presenting all the labs',
//     location: 'yellow 25',
//     queue_ID: 4,
//     receivingHelp: true
//   }
// ]
const sequelizeInit = require('./sequelize.js')
const sequelize = sequelizeInit.initSequelize()

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

// contains sequelize models of the queues.
// Dynamic length depending on how many queues (=#courses) we have
const queueModels = []

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
        }
      )
      )
      // console.log(users)
    }
  })
}

// 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
        }))
        console.log('course created', courses)
      }

      // adds students in queue to given course
      var queueItem = {
        studentID: queue.student,
        studentName: queue.users1.name,
        task: queue.task,
        location: queue.location,
        queueNo: queue.queueNo, // kanske inte behövs
        enterTime: queue.enterTime
      }

      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,
        })
        //myCourses.push({course: this.getCourse(r.courseID), level: r.role)
      }
    }
  }

  // let myCourses = []
  //
  // for (let courseID of coursIDs) {
  //   // let = index = courseIDs.indexOf(courses[i].ID);
  //   if (courseIDs.indexOf(courses[i].ID) != -1) {
  //     myCourses.push({course: courses[i], level:)
  //   }
  // }
  // console.log('in model: returning ', myCourses.length)
  return myCourses
}

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

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) => {
  console.log('in getQueue!')
  // console.log('getting ', courseID);
  return this.getQueues().get(courseID)
}

exports.getCourses = () => {
  var list = []
  for (var i = 0; i < courses.length; i++) {
    list.push(courses[i])
    console.log('added a course.', courses[i])
  }
  return list
}
// }

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.usersname)


      if (this.getHighestRole(userID) < req.role) {
        console.log('Too low authority', roleNames[req.role])
        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
}

exports.findIDfromEmail = (email) => {
  for (let user of users) {
    if( user.email === email) {
      console.log(user.email,email)
      console.log(user.ID)
      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, queueTemplate.length)
  for (let i = 0; i < queueTemplate.length; i++) {
    if (queueTemplate[i].queue_ID === queueItemID) {
      queueTemplate[i].receivingHelp = !queueTemplate[i].receivingHelp
      break
    }
  }
}

// DB integrated and cache
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
      }
    }
  }
}

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 index = findIndexOfAccount(asse)
    //   if (accounts[index].role === 0) {
    //     accounts[index].role = 1
    //   }
    //   roles.push({
    //     course_ID: courseObject.courseID,
    //     name: asse,
    //     role: 1,
    //     teacher_ID: accounts[index].ID
    //   })
    // }
    //
    // for (manager of confirmedManagers) {
    //   let index = findIndexOfAccount(manager)
    //   if (accounts[index].role < 2) {
    //     accounts[index].role = 2
    //   }
    //   roles.push({
    //     course_ID: courseObject.courseID,
    //     name: manager,
    //     role: 1,
    //     teacher_ID: accounts[index].ID
    //   })
    // }

    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)})
    }
  }

  /*
    for(let i = 0; i < courseObject.managers.length; i++){
        if(courseObject[i].)
    }
    let ID = 0;
    */
  return { success: true }
}

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

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



// exports.deleteCourse = (ID) => {
//   for (let i = 0; i < courses.length; i++) {
//     if (courses[i].ID === ID) {
//       console.log('in model, deleting course with ID ', ID)
//       courses.splice(i, 1)
//       break
//     }
//   }
//
//   for (let i = 0; i < roles.length; i++) {
//     if (roles[i].course_ID === ID) {
//       roles.splice(i, 1)
//     }
//   }
//
//   /*
//      * TODO: delete the queue for the course.
//      */
// }

exports.addQueueItem = (req) => {
  console.log('in model, addQueueItem, received ', req)
  /*
     * TODO: find the right course using req.courseID
     */
  for (let i = 0; i < queueTemplate.length; i++) {
    console.log('Searching: ' + queueTemplate[i].name + ', ' + req.queueObject.name)
    if (queueTemplate[i].name == req.queueObject.name) {
      console.log('Returning false!')
      return false
    }
  }
  queueTemplate.push(req.queueObject)
  return true
}

exports.registerNewUser = (userObject) => {
  console.log('In model registerNewUser, received ', userObject)
  let ID = 1
  for (let i = 0; i < accounts.length; i++) {
    if (accounts[i].name === userObject.username) {
      console.log('username already exists')
      return false
    }
    if (accounts[i].ID === ID) {
      ID++
    }
  }
  let newUser = {
    name: userObject.username,
    password: userObject.password,
    role: 0,
    ID: ID
  }
  accounts.push(newUser)
  console.log('In model, everything successful. accounts is now: ', accounts)
  return true
}