from app import db, models
from flask import flash, redirect, render_template, request, session, url_for

def userLogin():
  attemptedUser = request.form['loginName']
  attemptedPW = request.form['loginPW']
  userCheck = models.User.query.filter_by(accountName=attemptedUser).first()
  if userCheck == None:
    session['message'] = 'Error Logging In'
  else:
    if attemptedPW == userCheck.password:
      for x in vars(userCheck):
        if x[0] == '_':
          pass
        elif x == 'password':
          pass
        else:
          session[str(x)] = vars(userCheck)[x]
      session['message'] = None
    else:
      session['message'] = 'Error Logging In'
  return redirect(url_for('index'))

def userLogout():
  session.clear()
  return redirect(url_for('index'))

def listUsers(filter):
  userName = session['accountName']
  userCheck = models.User.query.filter_by(accountName=userName).first()
  if userCheck.accessLevel == 1:
    allUsers = models.User.query.order_by(models.User.employer).order_by(models.User.accountName).all()
    allClients = models.Client.query.all()
  else:
    employer = userCheck.employer
    getClient = models.Client.query.filter_by(accountName=employer).first()
    allUsers = getClient.hasUsers[:]
    allClients = models.Client.query.all()
  if filter != 'None':
    newBin = []
    for x in allUsers:
      if x.employer == filter:
        newBin.append(x)
    allUsers = newBin
  else:
    filter = None
  return render_template('users.html', userCheck=userCheck, allUsers=allUsers, allClients=allClients, filter=filter)

def addNewUser():
  attemptedName = request.form['newUserName']
  attemptedEmail = request.form['newUserEmail']
  attemptedPW = request.form['newUserPassword']
  attemptedAccess = request.form['newUserAccessLevel']
  attemptedWorkplace = request.form['newUserWorkplace']
  nameCheck = models.User.query.filter_by(accountName=attemptedName).first()
  if nameCheck != None:
    message = 'Name Already Used'
    return message
    return redirect(url_for('addUserPage'))
  emailCheck = models.User.query.filter_by(email=attemptedEmail).first()
  if emailCheck != None:
    message = 'Email Already Used'
    return message
    return redirect(url_for('addUserPage'))
  workplaceCheck = models.Client.query.filter_by(accountName=attemptedWorkplace).first()
  newUser = models.User(accountName=attemptedName, password=attemptedPW, email=attemptedEmail, accessLevel=attemptedAccess, workplace=workplaceCheck)
  db.session.add(newUser)
  db.session.commit()
  return redirect(url_for('userPage', wantedName=newUser.accountName))

def removeUser():
  attemptedUser = request.form['accountName']
  if attemptedUser == 'jreidl':
    return "Can't delete the architect"
  checkUser = models.User.query.filter_by(accountName=attemptedUser).first()
  if checkUser != None:
    db.session.delete(checkUser)
    db.session.commit()
  return redirect(url_for('usersPage'))

def updateUser(updateMe):
  user = models.User.query.filter_by(accountName=updateMe).first()
  if session['accountName'] == user.accountName:
    owner = True
  try:
    attemptedUser = request.form['accountName']
    if attemptedUser == user.accountName:
      pass
    else:
      attemptedUserCheck = models.User.query.filter_by(accountName=attemptedUser).first()
      if attemptedUserCheck == None:
        for x in user.ispConnection:
          x.forUser = attemptedUser
        user.accountName = attemptedUser
        if owner == True:
          session['accountName'] = user.accountName
      else:
        message = 'Name Already Used'
        return message
  except:
    pass
  try:
    attemptedEmail = request.form['accountEmail']
    if attemptedEmail == user.email:
      pass
    else:
      emailCheck = models.User.query.filter_by(email=attemptedEmail).first()
      if emailCheck == None:
        user.email = attemptedEmail
      else:
        message = 'Email Already Used'
        return message
  except:
    pass
  try:
    attemptedPassword = request.form['accountPassword']
    confirmPassword = request.form['confirmPassword']
    if attemptedPassword == '':
      pass
    else:
      if attemptedPassword != confirmPassword:
        return "Passwords don't match"
      elif attemptedPassword == confirmPassword:
        user.password = confirmPassword
  except:
    pass
  try:
    attemptedWorkplace = request.form['accountWorkplace']
    user.workplace = models.Client.query.filter_by(accountName=attemptedWorkplace).first()
  except:
    pass
  try:
    attemptedAccess = request.form['accountAccess']
    user.accessLevel = attemptedAccess
  except:
    pass
  db.session.commit()
  return redirect(url_for('userPage', wantedName=user.accountName))

def listClients():
  allClients = models.Client.query.order_by(models.Client.accountName).all()
  userName = session['accountName']
  userCheck = models.User.query.filter_by(accountName=userName).first()
  return render_template('clients.html', userCheck=userCheck, allClients=allClients)

def addClient():
  attemptedName = request.form['newClientName']
  clientCheck = models.Client.query.filter_by(accountName=attemptedName).first()
  if clientCheck == None:
    client = models.Client(accountName=attemptedName)
    db.session.add(client)
    db.session.commit()
  return redirect(url_for('clientsPage'))

def updateClient(updateMe):
  client = models.Client.query.filter_by(accountName=updateMe).first()
  if client == None:
    attemptedClient = request.form['accountName']
    client.accountName = attemptedClient
    db.session.commit()
  else:
    message = 'Name Already Used'
    return message
  return redirect(url_for('clientsPage'))

def removeClient():
  attemptedClient = request.form['accountName']
  if attemptedClient == 'Corona':
    return "Can't delete the architect's home"
  elif attemptedClient == 'Other':
    return "Can't delete the generic"
  checkClient = models.Client.query.filter_by(accountName=attemptedClient).first()
  if checkClient != None:
    for x in checkClient.hasUsers[:]:
      x.workplace = models.Client(accountName='Other')
    db.session.delete(checkClient)
    db.session.commit()
  return redirect(url_for('clientsPage'))

def listProjects(filter):
  userName = session['accountName']
  userCheck = models.User.query.filter_by(accountName=userName).first()
  if userCheck.accessLevel == 1:
    allProjects = models.Project.query.order_by(models.Project.forClientRef).order_by(models.Project.projectName).all()
    allClients = models.Client.query.all()
    if filter != 'None':
      newBin = []
      for x in allProjects:
        if x.forClientRef == filter:
          newBin.append(x)
      allProjects = newBin
    return render_template('projects.html', userCheck=userCheck, allProjects=allProjects, allClients=allClients, filter=filter)
  if userCheck.accessLevel == 2:
    employer = session['employer']
    getEmployer = models.Client.query.filter_by(accountName=employer).first()
    allClients = None
    allProjects = getEmployer.hasProjects[:]
  else:
    getUser = models.User.query.filter_by(accountName=userName).first()
    allClients = None
    allProjects = getUser.projects[:]
  return render_template('projects.html', userCheck=userCheck, allProjects=allProjects, allClients=allClients, filter=filter)

def addProject():
  attemptedProjectNumber = request.form['newProjectNumber']
  projectCheck = models.Project.query.filter_by(projectNumber=attemptedProjectNumber).first()
  if projectCheck == None:
    attemptedProjectName = request.form['newProjectName']
    attemptedForClient = request.form['newProjectClient']
    clientCheck = models.Client.query.filter_by(accountName=attemptedForClient).first()
    newProject = models.Project(projectNumber=attemptedProjectNumber, projectName=attemptedProjectName, forClient=clientCheck)
    db.session.add(newProject)
    db.session.commit()
  return redirect(url_for('projectPage', wantedProject=newProject.projectNumber))

def removeProject():
  attemptedProject = request.form['projectNumber']
  checkProject = models.Project.query.filter_by(projectNumber=attemptedProject).first()
  if checkProject != None:
    db.session.delete(checkProject)
    db.session.commit()
  return redirect(url_for('projectsPage'))

def updateProject(updateMe):
  project = models.Project.query.filter_by(projectNumber=updateMe).first()
  try:
    attemptedProjectNumber = request.form['projectNumber']
    if attemptedProjectNumber == project.projectNumber:
      pass
    else:
      project.projectNumber = attemptedProjectNumber
  except:
    pass
  try:
    attemptedProjectName = request.form['projectName']
    if attemptedProjectName == project.projectName:
      pass
    else:
      project.projectName = attemptedProjectName
  except:
    pass
  try:
    attemptedForClient = request.form['forClient']
    print attemptedForClient
    print project.forClientRef
    if attemptedForClient == project.forClientRef:
      pass
    else:
      clientCheck = models.Client.query.filter_by(accountName=attemptedForClient).first()
      project.forClient = clientCheck
  except:
    pass
  db.session.commit()
  return redirect(url_for('projectsPage'))

def addUserToProject(updateMe, forUser):
  project = models.Project.query.filter_by(projectNumber=updateMe).first()
  attemptedUser = forUser
  returnToUser = True
  if forUser == None:
    attemptedUser = request.form['addProjectUser']
    returnToUser = False
  userCheck = models.User.query.filter_by(accountName=attemptedUser).first()
  if userCheck not in project.users:
    userCheck.projects.append(project)
    db.session.commit()
  else:
    print 'user already on the project'
  if returnToUser:
    return redirect(url_for('userPage', wantedName=attemptedUser))
  return redirect(url_for('projectPage', wantedProject=project.projectNumber))

def removeUserFromProject(updateMe, forUser):
  print 'updateMe = ' + updateMe
  project = models.Project.query.filter_by(projectNumber=updateMe).first()
  print 'project = ' + project.projectName
  returnToUser = True
  attemptedUser = forUser
  if forUser == None:
    attemptedUser = request.form['removeProjectUser']
    returnToUser = False
  print 'attemptedUser = ' + attemptedUser
  userCheck = models.User.query.filter_by(accountName=attemptedUser).first()
  if userCheck != None:
    userCheck.projects.remove(project)
    db.session.commit()
  if returnToUser:
    return redirect(url_for('userPage', wantedName=attemptedUser))
  return redirect(url_for('projectPage', wantedProject=project.projectNumber))

def addUserConnection(updateMe):
  user = models.User.query.filter_by(accountName=updateMe).first()
  attemptedConnectionType = request.form['connectionType']
  attemptedISP = request.form['ispName']
  attemptedNetworkName = request.form['networkName']
  attemptedDownSpeed = int(request.form['downSpeed'])
  attemptedUpSpeed = int(request.form['upSpeed'])
  try:
    newConnection = models.userConnection(forUser=user.accountName, connectionType=attemptedConnectionType, ispName=attemptedISP, networkName=attemptedNetworkName, downSpeed=attemptedDownSpeed, upSpeed=attemptedUpSpeed)
    user.ispConnection.append(newConnection)
    db.session.commit()
  except:
    return 'could not add connection to user'
  return redirect(url_for('userPage', wantedName=user.accountName))

def removeUserConnection(projectID, forUser):
  removeForUser = models.User.query.filter_by(accountName=forUser).first()
  connection = models.userConnection.query.filter_by(id=projectID).first()
  try:
    removeForUser.ispConnection.remove(connection)
    db.session.commit()
  except:
    return 'could not remove connection'
  return redirect(url_for('userPage', wantedName=forUser))

def addProTitle(updateMe):
  user = models.User.query.filter_by(accountName=updateMe).first()
  attemptedTitle = request.form['proTitles']
  if attemptedTitle == '':
    return redirect(url_for('userPage', wantedName=user.accountName))
  try:
    newTitle = models.professionalTitle(type=attemptedTitle, forUser=user.accountName)
    user.proTitle.append(newTitle)
    db.session.commit()
  except:
    return 'could not add title'
  return redirect(url_for('userPage', wantedName=user.accountName))

def removeProTitle(titleID, forUser):
  removeForUser = models.User.query.filter_by(accountName=forUser).first()
  removeID = models.professionalTitle.query.filter_by(id=titleID).first()
  try:
    removeForUser.proTitle.remove(removeID)
    db.session.delete(removeID)
    db.session.commit()
  except:
    return 'could not remove title'
  return redirect(url_for('userPage', wantedName=forUser))