from django.shortcuts import render, redirect, get_object_or_404
from .models import *
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from .forms import *
from django.utils import timezone
from django.urls import reverse
from django.http import HttpResponse
from django.db.models import Q

from django.http import JsonResponse
from .models import Task, Epic


# Pages views

def signin(request):
    if request.user.is_authenticated:
        return redirect('home')

    if request.method == 'POST':
        form = CustomLoginForm(request.POST) 
        if form.is_valid():
            username = form.cleaned_data['username']
            password = form.cleaned_data['password']
            user = authenticate(request, username=username, password=password)

            if user is not None:
                login(request, user)
                return redirect('home')
            else:
                form.add_error(None, 'Invalid email or password. Please try again.')

    else:
        form = CustomLoginForm() 

    return render(request, 'login.html', {'form': form})


def signout(request):
    if request.user.is_authenticated:
        logout(request)
    return redirect('signin')


@login_required
def home(request, *args, **kwargs):
    notes = Note.objects.filter(user=request.user).order_by('-date')[:6]
    recent_note = Note.objects.last()

    if request.user.is_superuser:
        # Superadmin can see the last 8 tasks for all users
        tasks = Task.objects.filter(Q(status='Open') | Q(status='Working On')).order_by('-id')[:8]
        open_task_count = Task.objects.filter(status='Open').count()
        working_on_task_count = Task.objects.filter(status='Working On').count()
        total_tasks = open_task_count + working_on_task_count
    else:
        # Non-superadmin user can only see their assigned tasks
        tasks = Task.objects.filter(Q(assigned_to=request.user.staffprofile) & (Q(status='Open') | Q(status='Working On')))
        open_task_count = Task.objects.filter(assigned_to=request.user.staffprofile,status='Open').count()
        working_on_task_count = Task.objects.filter(assigned_to=request.user.staffprofile, status='Working On').count()
        total_tasks = open_task_count + working_on_task_count

    # Initialize last_note_color with a default color
    last_note_color = 'black'

    # Fetch the color of the last recent note
    if recent_note:
        last_note_color = recent_note.color

    context = {
        'notes': notes,
        'recent_note': recent_note,
        'tasks': tasks,
        'total_tasks' :total_tasks,
        'last_note_color': last_note_color, 

    }
    return render(request, 'index.html', context)


@login_required
def my_projects(request, *args, **kwargs):
    user = request.user

    try:
        staff_profile = StaffProfile.objects.get(user=user)

        projects = Project.objects.filter(models.Q(manager=staff_profile) | models.Q(members=staff_profile)).distinct().order_by('-project_id')

    except StaffProfile.DoesNotExist:
        projects = []
    
    context = {

   'projects' : projects,

    }
    return render(request, 'projects.html', context)


@login_required
def my_tasks(request, *args, **kwargs):
    
    context = {

    }
    return render(request, 'tasks.html', context)


@login_required
def customers(request, *args, **kwargs):
    customers = CustomerProfile.objects.all().order_by('-id')
    
    context = {
    'customers' : customers,

    }
    return render(request, 'customers.html', context)


@login_required
def detailed_project(request, project_id):
    project = get_object_or_404(Project, project_id=project_id)
    epics = Epic.objects.filter(project=project)

    selected_epic_id = request.GET.get('epic_id')  # Get the selected epic_id from the query parameters

    if selected_epic_id:
        selected_epic = get_object_or_404(Epic, id=selected_epic_id)
        related_tasks = Task.objects.filter(epic=selected_epic)
    else:
        selected_epic = None
        related_tasks = []

    context = {
        'project': project,
        'epics': epics,
        'selected_epic': selected_epic,  # Pass the selected epic to the template
        'related_tasks': related_tasks,  # Pass the related tasks to the template
    }

    return render(request, 'project-details.html', context)


@login_required
def createtask_project(request, project_id):
    project = get_object_or_404(Project, project_id=project_id)
    epics_of_my_project = Epic.objects.filter(project=project)
    staffs = StaffProfile.objects.all().order_by('-id')
    context = {  

    'project' : project,
    'epics_of_my_project' : epics_of_my_project,
    'staffs' : staffs,

    }
    return render(request, 'createtask-project.html', context)


@login_required
def create_project(request):
    staffs = StaffProfile.objects.all().order_by('-first_name')
    project_types = ProjectType.objects.all()
    customers = CustomerProfile.objects.all().order_by('-first_name')
    context = {       
    'staffs' : staffs,
    'project_types' : project_types,
    'customers' : customers,

    }
    return render(request, 'create-project.html', context)

@login_required
def create_epic(request, project_id):
    project = get_object_or_404(Project, project_id=project_id)

    context = {       
    'project' : project,
 

    }
    return render(request, 'create-epic.html', context)

@login_required
def create_task(request):
    context = {       

    }
    return render(request, 'create-task.html', context)


@login_required
def createtask_epic(request):
    context = {       

    }
    return render(request, 'createtask-epic.html', context)

@login_required
def add_customer(request):
    businesses = Business.objects.all().order_by('-id')
    references = Reference.objects.all().order_by('-id')
    context = {      
    'businesses' : businesses, 
    'references' :references

    }
    return render(request, 'add-customer.html', context)

@login_required
def customerdetails(request, customer_id):
    customer = get_object_or_404(CustomerProfile, customer_id=customer_id)
    context = {      
    'customer'  : customer,

    }
    return render(request, 'customer-details.html', context)
    

@login_required
def addbusiness(request):

    context = {


    }
    return render(request, 'add-business.html', context)

@login_required
def businessdetails(request):
    context = {       

    }
    return render(request, 'business-details.html', context)

@login_required
def businesses(request):
    context = {       

    }
    return render(request, 'businesses.html', context)

@login_required
def adduser(request):

    context = {


    }
    return render(request, 'add-user.html', context)

@login_required
def userdetails(request):

    context = {


    }
    return render(request, 'user-details.html', context)

@login_required
def users(request):

    context = {


    }
    return render(request, 'users.html', context)



@login_required
def detailed_task(request, task_id):
    task = get_object_or_404(Task, task_id=task_id)

    context = {
        'task': task,

    }

    return render(request, 'task-details.html', context)
















# Modals views

def add_note_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'addnote-modal.html', context)   


def add_status_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'addstatus-modal.html', context)

def add_file_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'addfile-modal.html', context) 

def add_credentials_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'addcredentials-modal.html', context) 


def add_point_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'addpoint-modal.html', context)

def add_time_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'addtime-modal.html', context)

def delete_task_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'deletetask-modal.html', context)

def show_points_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'showpoints-modal.html', context)

def timeline_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'timeline-modal.html', context)

def update_status_modal(request, *args, **kwargs):
    context = {

    }
    return render(request, 'update-status-modal.html', context)




#Save Functions
@login_required
def save_note(request):
    if request.method == 'POST':
        text = request.POST.get('note_text')
        color = request.POST.get('note_color')
        user = request.user
        date = timezone.now()

        note = Note(
            text=text,
            color=color,
            user=user,
            date=date,
        )
        note.save()

        # Reload the parent page
        return HttpResponse('<script>window.top.location.reload();</script>')

    return render(request, 'addnote-modal.html') 



@login_required
def save_project(request):
    if request.method == 'POST':
        name = request.POST.get('name')
        customer_username = request.POST.get('customer')
        manager_username = request.POST.get('manager')
        project_type = request.POST.getlist('project_type')
        details = request.POST.get('details')
        members_usernames = request.POST.getlist('members')
        status = request.POST.get('status')
        start_date = request.POST.get('start_date')
        end_date = request.POST.get('end_date') 

        try:
            customer_profile = CustomerProfile.objects.get(user__username=customer_username)
            manager_profile = StaffProfile.objects.get(user__username=manager_username)
            members_profiles = StaffProfile.objects.filter(user__username__in=members_usernames)
        except (CustomerProfile.DoesNotExist, StaffProfile.DoesNotExist):
            # Handle the case where customer_profile or manager_profile is not found
            pass

        # Create and save the project
        project = Project(
            name=name,
            customer=customer_profile,
            manager=manager_profile,
            details=details,
            status=status,
            start_date=start_date,
            end_date=end_date,
        )
        project.save()
        
        project.project_type.set(project_type)
        project.members.set(members_profiles)

        # Save project requirements
        requirements = request.POST.getlist('requirements')  # Assuming 'requirements' is the name of your requirement input field
        for requirement_content in requirements:
            if requirement_content:
                requirement = ProjectRequirement(content=requirement_content, project=project)
                requirement.save()

        return redirect('my-projects')



@login_required
def save_epic(request):
    if request.method == 'POST':
        title = request.POST.get('title')
        status = request.POST.get('status')
        description = request.POST.get('description')
        project_id = request.POST.get('project')  # Get project ID as a string

        # Retrieve the Project instance
        try:
            project = Project.objects.get(id=project_id)
        except Project.DoesNotExist:
            # Handle the case where the project with the provided ID doesn't exist
            # You might want to display an error message or redirect to an appropriate page.
            pass 

        start_date = request.POST.get('start_date')
        end_date = request.POST.get('end_date')

        # Create the Epic object with the Project instance
        epic = Epic(
            title=title,
            status=status,
            project=project,  # Assign the Project instance
            description=description,
            start_date=start_date,
            end_date=end_date
        )

        # Save the Epic object to the database
        epic.save()

        # Redirect to the detailed project page
        redirect_url = reverse('detailed-project', args=[project.project_id])
        return redirect(redirect_url)


@login_required
def save_task(request):
    if request.method == 'POST':
        name = request.POST.get('name')
        status = request.POST.get('status')
        project_id = request.POST.get('project')
        epic_id = request.POST.get('epic')
        assigned_to_id = request.POST.get('assigned_to')
        extra = request.POST.get('extra') 
        description = request.POST.get('description')   
        start_date = request.POST.get('start_date')   
        end_date = request.POST.get('end_date')   

        try:
            project = Project.objects.get(id=project_id)
        except Project.DoesNotExist:
            # Handle the case where the project with the provided ID doesn't exist
            # You might want to display an error message or redirect to an appropriate page.
            pass

        try:
            epic = Epic.objects.get(id=epic_id)
        except Epic.DoesNotExist:
            # Handle the case where the epic with the provided ID doesn't exist
            # You might want to display an error message or redirect to an appropriate page.
            pass

        try:
   
            assigned_to = StaffProfile.objects.get(id=assigned_to_id)
        except StaffProfile.DoesNotExist:
            # Handle the case where the StaffProfile with the provided ID doesn't exist
            # You might want to display an error message or redirect to an appropriate page.
            pass


        # Create the Task object with the Project and Epic instances
        task = Task(
            name=name,
            status=status,
            project=project, 
            epic=epic,
            extra=extra,
            description=description,
            start_date=start_date,
            end_date=end_date,
            assigned_to = assigned_to

        )

        # Save the Task object to the database
        task.save()

        # Redirect to the detailed project page
        redirect_url = reverse('detailed-project', args=[project.project_id])  
        return redirect(redirect_url)


def fetch_related_tasks(request):
    # Get the selected epic ID from the request
    epic_id = request.GET.get("epic_id")

    # Fetch tasks related to the selected epic along with their project
    related_tasks = Task.objects.filter(epic_id=epic_id).select_related("project")

    task_data = [
        {
            "name": task.name,
            "status": task.status,
            "start_date": task.formatted_start_date(),
            "end_date": task.formatted_end_date(),
            "extra": task.extra,
        }
        for task in related_tasks
    ]

    return JsonResponse({"tasks": task_data})


@login_required
def save_business(request):
    if request.method == 'POST':
        name = request.POST.get('name')
        email= request.POST.get('email')
        financial_number = request.POST.get('financial_number')
        phone_number = request.POST.get('phone_number')
        vat = request.POST.get('vat')
        commercial_registration = request.POST.get('commercial_registration')
        website = request.POST.get('website')
        business_type = request.POST.get('business_type')
        logo = request.POST.get('logo')

        business = Business(
        name = name,
        email = email,
        financial_number = financial_number,
        vat = vat,
        commercial_registration = commercial_registration,
        website = website,
        business_type = business_type,
        logo = logo,
        phone_number = phone_number,
        )
        business.save()


       
    return render(request, 'add-business.html') 


def save_customer(request):
    if request.method == 'POST':
        form = SignUpForm(request.POST)
        if form.is_valid():
            email = form.cleaned_data['email']
            first_name = form.cleaned_data['first_name'].replace(" ", "")  # Remove spaces
            last_name = form.cleaned_data['last_name'].replace(" ", "")  # Remove spaces
            
            username = f"{first_name.lower()}{last_name.lower()}"
            original_username = username
            counter = 1  # Initialize a counter to add numbers
            
            while User.objects.filter(username=username).exists():
                # If the username already exists, append the counter to it
                username = f"{original_username.lower()}{counter}"
                counter += 1
            
            user = User.objects.create_user(
                username=username,
                email=email,
                password=form.cleaned_data['password']
            )
            user.first_name = form.cleaned_data['first_name']
            user.last_name = form.cleaned_data['last_name']
            user.save()

            customer_profile = form.save(commit=False)
            customer_profile.user = user
            customer_profile.save()

    return redirect('customers')


@login_required
def save_status(request):
    if request.method == 'POST':
        text = request.POST.get('text')
        current_datetime = timezone.now()
        date = current_datetime.date() 
        time = current_datetime.hour  

        try:
            staff_profile = StaffProfile.objects.get(user=request.user)
        except StaffProfile.DoesNotExist:
            # Handle the case where a StaffProfile does not exist for the user
            staff_profile = None

        status = Status(
            text=text,
            staff=staff_profile,
            date=date,
            time = time,
        )
        status.save()

        # Reload the parent page
        return HttpResponse('<script>window.top.location.reload();</script>')

    return render(request, 'addstatus-modal.html')