from django.shortcuts import render
from django.http import Http404
import redis
from redis_app.utils.index import create_index
from redis_app.utils.model import *
# This model only helps us the development part to set rules on objects (we do not use the django model to save objects in it)
from .models import Person

redis_connection = redis.Redis(host='localhost', port=6379, decode_responses=True)
pub_sub = redis_connection.pubsub()
create_index(redis_connection=redis_connection)

def home(request):
    person = request.session.get("person", "")
    return render(request, 'home.html', {'person': person})

def details(request, course_id, error_message='', success_message=''):
    person = request.session.get("person", "")
    if isExpired(course_id):
        raise Http404("Course has expired... Get faster next time!")
    course = getCourse(course_id)
    if not course:
        raise Http404("Course does not exist")
    course['id'] = course_id
    teacher = getPerson(course['teacher'])
    if not teacher:
        raise Http404("Teacher does not exist")
    course['teacher_name'] = teacher['name']
    register = isPersonRegisteredToCourse(course, person)
    full = isCourseFull(course)
    return render(request, 'details.html', {'course': course, 'person': person, 'register': register, 'full': full, 'error_message': error_message, 'success_message': success_message})

def register(request):
    if request.method == 'POST':
        person = register_redis(request.POST['name'], request.POST['role'])
        if not person:
            return render(request, 'register.html', {'person': Person(name="", role=""), "error_message": "This user already exists!"})
        request.session["person"] = person
        return home(request)
        
    return render(request, 'register.html', {'person': Person(name="", role=""), "error_message": "The form has been wrongly filled!"})

def login(request):
    if request.method == 'POST':
        person = login_redis(request.POST["name"], request.POST["role"])
        if not person:
            return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "No user found!"})
        request.session["person"] = person
        return home(request)
    return login_form(request)

def register_form(request):
    return render(request, 'register.html', {'person': Person(name="", role="")})

def login_form(request):
    return render(request, 'login.html', {'person': Person(name="", role="")})

def logout(request):
    request.session["person"] = ""
    return render(request, 'login.html', {'person': Person(name="", role="")})

def courses(request, error_message="", success_message=""):
    person = request.session.get("person", "")
    if person == "":
        return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "You must login!"})
    person_id = getPersonId(person["name"], person["role"]).split(":")[1]

    courses = getCoursesFromPerson(person_id)
    return render(request, 'courses.html', {'person': person, 'courses': courses, 'error_message': error_message, 'success_message': success_message})

def change_profile(request):
    person = request.session.get("person", "")
    if person == '':
        return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "You must login!"})
    
    if request.method == 'POST':
        person_name = request.POST['name']
        person_role = request.POST['role']

        person_id = getPersonId(person["name"], person["role"])
        if not person_id:
            return render(request, 'profile.html', {'person': person, "error_message": "Internal error: No user found!"})
        redis_connection.hmset(person_id, mapping={"name": person_name, "role": person_role})
        
        person["name"] = person_name
        person["role"] = person_role
        request.session["person"] = person
        return render(request, 'profile.html', {'person': person, 'success_message': 'Your profile has been successfully changed!'})
    
    return login_form(request)

def profile(request):
    person = request.session.get("person", "")
    if person == '':
        return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "You must login!"})
    return render(request, 'profile.html', {'person': person})

def delete_course_view(request, course_id):
    if isExpired(course_id):
        raise Http404("Course has expired... Get faster next time!")
    res = delete_course(course_id)
    if not res:
        return courses(request)
    publish(course_id, f"DELETE: Course:{course_id} has been deleted!")
    return courses(request)

def publish_message(request):
    person = request.session.get("person", "")
    courses_fetched = getCoursesFromPerson(getPersonId(person['name'], person['role']).split(":")[1])
    for course in courses_fetched:
        course['id'] = getCourseId(course).split(':')[1]
    if not courses_fetched:
        return courses(request, 'You don\'t have any course. You must create one to publish a message!')
    return render(request, 'publish_message.html', {'person': person, 'courses': courses_fetched, 'success_message': 'The message has been successfully sent!'})

def publish_message_form(request):
    person = request.session.get("person", "")
    if person == '':
        return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "You must login!"})
    if person['role'] == 'Student':
        return render(request, 'publish_message.html', {'person': person, "error_message": "The form has been wrongly filled!"})
    if request.method == 'POST':
        course_id = request.POST['course_id']
        message = request.POST['message']
        course = redis_connection.hgetall(f'course:{course_id}')
        if not course:
            raise Http404("Course not found")
        publish(course_id, message)
        return publish_message(request)
        
    return render(request, 'publish_message.html', {'person': person, "error_message": "The form has been wrongly filled!"})

def create_course_view(request):
    person = request.session.get("person", "")
    return render(request, 'create.html', {'person': person})

def update_course_view(request, course_id):
    person = request.session.get("person", "")
    if isExpired(course_id):
        raise Http404("Course has expired... Get faster next time!")
    course = redis_connection.hgetall(f"course:{course_id}")
    if not course:
        raise Http404("Course does not exist")
    course_id = getCourseId2(course['title'], course['teacher'])
    if course_id == False:
        raise Http404("Course does not exist")
    course['id'] = course_id.split(":")[1]
    return render(request, 'update.html', {'person': person, 'course': course})

def create_course_form(request):
    person = request.session.get("person", "")
    if person == '':
        return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "You must login!"})
    if request.method == 'POST':
        course_title = request.POST['title']
        course_summary = request.POST['summary']
        course_level = request.POST['level']
        course_places = request.POST['places']
        course_teacher = getPersonId(person['name'], person['role']).split(":")[1]
        create_course(course_title, course_summary, course_level, course_places, course_teacher)
        return courses(request, "", "The course has been successfully created!")
        
    return render(request, 'create.html', {'person': person, "error_message": "The form has been wrongly filled!"})

def update_course_form(request, course_id):
    person = request.session.get("person", "")
    if isExpired(course_id):
        raise Http404("Course has expired... Get faster next time!")
    if person == '':
        return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "You must login!"})
    if request.method == 'POST':
        course_title = request.POST['title']
        course_summary = request.POST['summary']
        course_level = request.POST['level']
        course_places = request.POST['places']
        course_teacher = getPersonId(person['name'], person['role']).split(":")[1]
        course = redis_connection.hgetall(f"course:{course_id}")
        course["id"] = course_id
        course_students = course.get("students", "")
        try:
            if course_students and len(course_students.split(',')) >= int(course_places):
                return render(request, 'update.html', {'person': person, "error_message": "There's too many students registered to decrease the number of places that much!", "course": course})
        except:
            return render(request, 'update.html', {'person': person, "error_message": "The number of places has not the right format!", "course": course})
        update_course(course_id, course_title, course_summary, course_level, course_places, course_teacher)
        return courses(request, "", "The course has been successfully changed!")
        
    return render(request, 'update.html', {'person': person, "error_message": "The form has been wrongly filled!", "course": course})

def course_register_view(request, course_id):
    person = request.session.get("person", "")
    if isExpired(course_id):
        raise Http404("Course has expired... Get faster next time!")
    person_id = getPersonId(person["name"], person["role"]).split(":")[1]
    if not person_id:
        raise Http404("Person not found")
    course = redis_connection.hgetall(f"course:{course_id}")
    if not course:
        raise Http404("Course not found")
    course["id"] = course_id
    teacher = redis_connection.hgetall(f"person:{course['teacher']}")
    if not teacher:
        raise Http404("Teacher does not exist")
    course['teacher_name'] = teacher['name']
    if course_register(course_id, person_id):
        return details(request, course_id, '', 'Successfully registered to the course.')
    return details(request, course_id, "Could not register to the course. Try again later.")

def course_unregister_view(request, course_id):
    person = request.session.get("person", "")
    if person == "":
        return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "You must login!"})
    if isExpired(course_id):
        raise Http404("Course has expired... Get faster next time!")
    person_id = getPersonId(person["name"], person["role"]).split(":")[1]
    if not person_id:
        raise Http404("Person not found")
    course = redis_connection.hgetall(f"course:{course_id}")
    if not course:
        raise Http404("Course not found")
    course["id"] = course_id
    teacher = redis_connection.hgetall(f"person:{course['teacher']}")
    if not teacher:
        raise Http404("Teacher does not exist")
    course['teacher_name'] = teacher['name']
    if course_unregister(course_id, person_id):
        return details(request, course_id, '', "Successfully unregistered to the course.")
    return details(request, course_id, "Could not unregister to the course. Try again later.")

def search(keywords):
    courses = []
    for keyword in keywords.split(' '):
        if not keyword: # When the users end his keywords with a ' '
            continue
        title_query = f"@title:{keyword}"
        summary_query = f"@summary:{keyword}"
        level_query = f"@level:{keyword}"
        teacher_query = f"@teacher:{keyword}"
        title_results = redis_connection.execute_command('FT.SEARCH', 'idx:courses', title_query)
        summary_results = redis_connection.execute_command('FT.SEARCH', 'idx:courses', summary_query)
        level_results = redis_connection.execute_command('FT.SEARCH', 'idx:courses', level_query)
        teacher_results = redis_connection.execute_command('FT.SEARCH', 'idx:courses', teacher_query)
        for i in range(1, len(title_results), 2):
            courses.append(title_results[i])
        for i in range(1, len(summary_results), 2):
            courses.append(summary_results[i])
        for i in range(1, len(level_results), 2):
            courses.append(level_results[i])
        for i in range(1, len(teacher_results), 2):
            courses.append(teacher_results[i])
    return courses

def search_view(request):
    person = request.session.get("person", "")
    return render(request, 'search.html', {'person': person})

def search_form(request):
    person = request.session.get("person", "")
    if request.method == 'POST':
        keywords = request.POST['keywords']
        courses = []
        courses_id = search(keywords)
        for course_id in courses_id:
            course = redis_connection.hgetall(course_id)
            if not course:
                continue
            course['id'] = course_id.split(":")[1]
            courses.append(course)
        return render(request, 'search.html', {'person': person, 'courses': courses})
        
    return render(request, 'search.html', {'person': person, "error_message": "The form has been wrongly filled!"})
    
def notifications_view(request):
    person = request.session.get("person", "")
    messages = request.session.get("messages", [])
    return render(request, 'notifications.html', {'person': person, 'messages': messages})

def notifications(request):
    person = request.session.get("person", "")
    messages = request.session.get("messages", [])
    if person == "":
        return render(request, 'login.html', {'person': Person(name="", role=""), "error_message": "You must login!"})
    pub_sub.punsubscribe()
    courses_id = [course['id'] for course in getCoursesFromPerson(getPersonId(person['name'], person['role']).split(":")[1])]
    if not courses_id:
        return courses(request, "You're not registered to any course. Please register to one to follow notifications.")
    pub_sub.psubscribe(*courses_id)

    for message in pub_sub.listen():
        if message["type"] != 'pmessage':
            continue
        messages.append(message)
        messages.reverse()
        request.session["message"] = messages
        break
    return notifications_view(request)
    
def clear_notifications(request):
    request.session["messages"] = []
    return notifications_view(request)

# Every id is only the number, not the course:number or person:number