from django.shortcuts import redirect, render
from django.contrib import messages
from datetime import datetime
from django.db.models import Q, Sum
from account.models import *
from django.core.paginator import Paginator
from .utils.decorators import role_required
from django.contrib.auth import get_user_model
from django.contrib.auth.decorators import login_required
User = get_user_model()
from .choices import *
from .variable import *
from .custom_today import get_custom_today

today = datetime.today()



# TODO: PET
@login_required
def select_multiple_pet(request):
    if request.method == "POST":
        date = request.POST.get("date")
        by_annual = request.POST.get("by_annual")
        auth = request.POST.get("auth")
        selected_members = request.POST.getlist("members")  # List of selected member IDs
        if not date or not by_annual:
            messages.error(request, "Please fill in all required fields.")
            return redirect("select_multiple_pet")

        members_queryset = Member.objects.filter(id__in=selected_members)
        for member in members_queryset:
            PETMultiple.objects.create(member=member,date=date,by_annual=by_annual,auth=auth)

        messages.success(request, "Multiple IPFT created successfully.")
        return redirect("create_multiple_pet")

    role = request.user.role
    if role and role.modules.filter(name='create_pet_admin').exists():
        members = Member.objects.filter(active=True).order_by('rank')
    elif role and role.modules.filter(name='create_pet_battalion').exists():
        companies = request.user.battalion.companies.all()
        members = Member.objects.filter(active=True, company__in=companies).order_by('rank')
    elif role and role.modules.filter(name='create_pet_company').exists():
        company = request.user.company
        members = Member.objects.filter(active=True, company=company).order_by('rank')
    else:
        return render(request, 'others/no_permission.html')
    

    context = {
        "members": members,
        "by_annuals": BY_ANNUAL_LIST
        }
    return render(request, "multiple/select_pet.html", context)

def create_multiple_pet(request):
    role = request.user.role
    if role and role.modules.filter(name='create_pet_admin').exists():
        pets = PETMultiple.objects.filter(date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_pet_battalion').exists():
        companies = request.user.battalion.companies.all()
        pets = PETMultiple.objects.filter(member__company__in=companies, date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_pet_company').exists():
        company = request.user.company
        pets = PETMultiple.objects.filter(member__company=company, date=today, submit=False).order_by('member__rank')
    else:
        return render(request, 'others/no_permission.html')


    if request.method == "POST":
        for item in pets:
            member_id = item.member.id
            result = request.POST.get(f"result_{member_id}")
            attempt = request.POST.get(f"attempt_{member_id}")
            remark = request.POST.get(f"remark_{member_id}")
            reason = request.POST.get(f"reason_{member_id}")

            # Create PET record
            PET.objects.create(
                member=item.member,
                date=item.date,
                by_annual=item.by_annual,
                auth=item.auth,
                result=result,
                attempt=attempt,
                remark=remark,
                reason=reason
            )
            item.submit = True
            item.save()
        messages.success(request, "Multiple IPFT created successfully.")
        return redirect("read_pet")  # redirect to a success page


    context = {
        "pets": pets,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "remarks":REMARK_LIST,
        "reasons":REASON_LIST,
    }
    return render(request, "multiple/create_pet.html", context)


# TODO: RET
@login_required
def select_multiple_ret(request):
    if request.method == "POST":
        date = request.POST.get("date")
        auth = request.POST.get("auth")
        selected_members = request.POST.getlist("members")  # List of selected member IDs
        if not date:
            messages.error(request, "Please fill in all required fields.")
            return redirect("select_multiple_ret")

        members_queryset = Member.objects.filter(id__in=selected_members)
        for member in members_queryset:
            RETMultiple.objects.create(member=member,date=date,auth=auth)

        messages.success(request, "Multiple Firing created successfully.")
        return redirect("create_multiple_ret")

    role = request.user.role
    if role and role.modules.filter(name='create_ret_admin').exists():
        members = Member.objects.filter(active=True).order_by('rank')
    elif role and role.modules.filter(name='create_ret_battalion').exists():
        companies = request.user.battalion.companies.all()
        members = Member.objects.filter(active=True, company__in=companies).order_by('rank')
    elif role and role.modules.filter(name='create_ret_company').exists():
        company = request.user.company
        members = Member.objects.filter(active=True, company=company).order_by('rank')
    else:
        return render(request, 'others/no_permission.html')
    

    context = {
        "members": members,
        }
    return render(request, "multiple/select_ret.html", context)

def create_multiple_ret(request):
    role = request.user.role
    if role and role.modules.filter(name='create_ret_admin').exists():
        rets = RETMultiple.objects.filter(date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_ret_battalion').exists():
        companies = request.user.battalion.companies.all()
        rets = RETMultiple.objects.filter(member__company__in=companies, date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_ret_company').exists():
        company = request.user.company
        rets = RETMultiple.objects.filter(member__company=company, date=today, submit=False).order_by('member__rank')
    else:
        return render(request, 'others/no_permission.html')


    if request.method == "POST":
        for item in rets:
            member_id = item.member.id
            result = request.POST.get(f"result_{member_id}")
            attempt = request.POST.get(f"attempt_{member_id}")
            gp = request.POST.get(f"gp_{member_id}")
            hit = request.POST.get(f"hit_{member_id}")
            total = request.POST.get(f"total_{member_id}")
            ret = request.POST.get(f"ret_{member_id}")
            remark = request.POST.get(f"remark_{member_id}")
            reason = request.POST.get(f"reason_{member_id}")

            # Create PET record
            RET.objects.create(
                member=item.member,
                date=item.date,
                auth=item.auth,
                result=result,
                attempt=attempt,
                remark=remark,
                reason=reason,
                gp=gp,
                hit=hit,
                total=total,
                ret=ret
            )
            item.submit = True
            item.save()
        messages.success(request, "Multiple Firing created successfully.")
        return redirect("read_ret")  # redirect to a success page


    context = {
        "rets": rets,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "gps":GP_LIST,
        "reasons":REASON_LIST,
        "remarks":REMARK_LIST,
        "ret_choices":Yes_No,

    }
    return render(request, "multiple/create_ret.html", context)





# TODO: GR Firing
@login_required
def select_multiple_gr_firing(request):
    if request.method == "POST":
        date = request.POST.get("date")
        auth = request.POST.get("auth")
        selected_members = request.POST.getlist("members")  # List of selected member IDs
        if not date:
            messages.error(request, "Please fill in all required fields.")
            return redirect("select_multiple_gr_firing")

        members_queryset = Member.objects.filter(id__in=selected_members)
        for member in members_queryset:
            GRFiringMultiple.objects.create(member=member,date=date,auth=auth)

        messages.success(request, "Multiple Gran Firing created successfully.")
        return redirect("create_multiple_gr_firing")

    role = request.user.role
    if role and role.modules.filter(name='create_gr_firing_admin').exists():
        members = Member.objects.filter(active=True).order_by('rank')
    elif role and role.modules.filter(name='create_gr_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        members = Member.objects.filter(active=True, company__in=companies).order_by('rank')
    elif role and role.modules.filter(name='create_gr_firing_company').exists():
        company = request.user.company
        members = Member.objects.filter(active=True, company=company).order_by('rank')
    else:
        return render(request, 'others/no_permission.html')
    

    context = {
        "members": members,
        }
    return render(request, "multiple/select_gr_firing.html", context)



def create_multiple_gr_firing(request):
    role = request.user.role
    if role and role.modules.filter(name='create_gr_firing_admin').exists():
        gr_firings = GRFiringMultiple.objects.filter(date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_gr_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        gr_firings = GRFiringMultiple.objects.filter(member__company__in=companies, date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_gr_firing_company').exists():
        company = request.user.company
        gr_firings = GRFiringMultiple.objects.filter(member__company=company, date=today, submit=False).order_by('member__rank')
    else:
        return render(request, 'others/no_permission.html')


    if request.method == "POST":
        for item in gr_firings:
            member_id = item.member.id
            result = request.POST.get(f"result_{member_id}")
            attempt = request.POST.get(f"attempt_{member_id}")
            remark = request.POST.get(f"remark_{member_id}")
            reason = request.POST.get(f"reason_{member_id}")
            total = request.POST.get(f"total_{member_id}")

            # Create PET record
            GRFiring.objects.create(
                member=item.member,
                date=item.date,
                auth=item.auth,
                result=result,
                attempt=attempt,
                remark=remark,
                reason=reason,
                total=total
            )
            item.submit = True
            item.save()
        messages.success(request, "Multiple Gren Firing created successfully.")
        return redirect("read_gr_firing")  # redirect to a success page


    context = {
        "gr_firings": gr_firings,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "remarks":REMARK_LIST,
        "reasons":REASON_LIST,
    }
    return render(request, "multiple/create_gr_firing.html", context)




# TODO: SM
@login_required
def select_multiple_sm(request):
    if request.method == "POST":
        date = request.POST.get("date")
        auth = request.POST.get("auth")
        selected_members = request.POST.getlist("members")  # List of selected member IDs
        if not date:
            messages.error(request, "Please fill in all required fields.")
            return redirect("select_multiple_sm")

        members_queryset = Member.objects.filter(id__in=selected_members)
        for member in members_queryset:
            SMMultiple.objects.create(member=member,date=date,auth=auth)

        messages.success(request, "Speed March created successfully.")
        return redirect("create_multiple_sm")

    role = request.user.role
    if role and role.modules.filter(name='create_sm_admin').exists():
        members = Member.objects.filter(active=True).order_by('rank')
    elif role and role.modules.filter(name='create_sm_battalion').exists():
        companies = request.user.battalion.companies.all()
        members = Member.objects.filter(active=True, company__in=companies).order_by('rank')
    elif role and role.modules.filter(name='create_sm_company').exists():
        company = request.user.company
        members = Member.objects.filter(active=True, company=company).order_by('rank')
    else:
        return render(request, 'others/no_permission.html')
    

    context = {
        "members": members,
        }
    return render(request, "multiple/select_sm.html", context)



def create_multiple_sm(request):
    role = request.user.role
    if role and role.modules.filter(name='create_sm_admin').exists():
        sms = SMMultiple.objects.filter(date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_sm_battalion').exists():
        companies = request.user.battalion.companies.all()
        sms = SMMultiple.objects.filter(member__company__in=companies, date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_sm_company').exists():
        company = request.user.company
        sms = SMMultiple.objects.filter(member__company=company, date=today, submit=False).order_by('member__rank')
    else:
        return render(request, 'others/no_permission.html')


    if request.method == "POST":
        for item in sms:
            member_id = item.member.id
            result = request.POST.get(f"result_{member_id}")
            attempt = request.POST.get(f"attempt_{member_id}")
            remark = request.POST.get(f"remark_{member_id}")
            reason = request.POST.get(f"reason_{member_id}")

            # Create PET record
            SM.objects.create(
                member=item.member,
                date=item.date,
                auth=item.auth,
                result=result,
                attempt=attempt,
                remark=remark,
                reason=reason,
            )
            item.submit = True
            item.save()
        messages.success(request, "Multiple Speed March created successfully.")
        return redirect("read_sm")  # redirect to a success page


    context = {
        "sms": sms,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "remarks":REMARK_LIST,
        "reasons":REASON_LIST,
    }
    return render(request, "multiple/create_sm.html", context)






# TODO: AsltCourse
@login_required
def select_multiple_aslt_course(request):
    if request.method == "POST":
        date = request.POST.get("date")
        auth = request.POST.get("auth")
        selected_members = request.POST.getlist("members")  # List of selected member IDs
        if not date:
            messages.error(request, "Please fill in all required fields.")
            return redirect("select_multiple_aslt_course")

        members_queryset = Member.objects.filter(id__in=selected_members)
        for member in members_queryset:
            AsltCourseMultiple.objects.create(member=member,date=date,auth=auth)

        messages.success(request, "Multipl Aslt Course created successfully.")
        return redirect("create_multiple_aslt_course")

    role = request.user.role
    if role and role.modules.filter(name='create_aslt_course_admin').exists():
        members = Member.objects.filter(active=True).order_by('rank')
    elif role and role.modules.filter(name='create_aslt_course_battalion').exists():
        companies = request.user.battalion.companies.all()
        members = Member.objects.filter(active=True, company__in=companies).order_by('rank')
    elif role and role.modules.filter(name='create_aslt_course_company').exists():
        company = request.user.company
        members = Member.objects.filter(active=True, company=company).order_by('rank')
    else:
        return render(request, 'others/no_permission.html')
    

    context = {
        "members": members,
        }
    return render(request, "multiple/select_aslt_course.html", context)



def create_multiple_aslt_course(request):
    role = request.user.role
    if role and role.modules.filter(name='create_aslt_course_admin').exists():
        aslt_courses = AsltCourseMultiple.objects.filter(date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_aslt_course_battalion').exists():
        companies = request.user.battalion.companies.all()
        aslt_courses = AsltCourseMultiple.objects.filter(member__company__in=companies, date=today, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_aslt_course_company').exists():
        company = request.user.company
        aslt_courses = AsltCourseMultiple.objects.filter(member__company=company, date=today, submit=False).order_by('member__rank')
    else:
        return render(request, 'others/no_permission.html')


    if request.method == "POST":
        for item in aslt_courses:
            member_id = item.member.id
            result = request.POST.get(f"result_{member_id}")
            attempt = request.POST.get(f"attempt_{member_id}")
            remark = request.POST.get(f"remark_{member_id}")
            reason = request.POST.get(f"reason_{member_id}")

            # Create PET record
            AsltCourse.objects.create(
                member=item.member,
                date=item.date,
                auth=item.auth,
                result=result,
                attempt=attempt,
                remark=remark,
                reason=reason,
            )
            item.submit = True
            item.save()
        messages.success(request, "Multiple Aslt Course created successfully.")
        return redirect("read_aslt_course")  # redirect to a success page


    context = {
        "aslt_courses": aslt_courses,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "remarks":REMARK_LIST,
        "reasons":REASON_LIST,
    }
    return render(request, "multiple/create_aslt_course.html", context)



# TODO: Ex Performance
@login_required
def select_multiple_ex_perf(request):
    if request.method == "POST":
        date_from = request.POST.get("date_from")
        date_to = request.POST.get("date_to")
        ex_perf_name_id = request.POST.get("ex_perf_name")
        selected_members = request.POST.getlist("members")  # List of selected member IDs
        if not date_from or not date_to:
            messages.error(request, "Please fill in all required fields.")
            return redirect("select_multiple_ex_perf")

        members_queryset = Member.objects.filter(id__in=selected_members)
        for member in members_queryset:
            ExPerfMultiple.objects.create(member=member,date_from=date_from,date_to=date_to,ex_perf_name_id=ex_perf_name_id)

        messages.success(request, "Multiple Ex Performance created successfully.")
        return redirect("create_multiple_ex_perf")

    role = request.user.role
    if role and role.modules.filter(name='create_ex_perf_admin').exists():
        members = Member.objects.filter(active=True).order_by('rank')
    elif role and role.modules.filter(name='create_ex_perf_battalion').exists():
        companies = request.user.battalion.companies.all()
        members = Member.objects.filter(active=True, company__in=companies).order_by('rank')
    elif role and role.modules.filter(name='create_ex_perf_company').exists():
        company = request.user.company
        members = Member.objects.filter(active=True, company=company).order_by('rank')
    else:
        return render(request, 'others/no_permission.html')
    

    context = {
        "members": members,
        "ex_perf_names": ExPerfName.objects.all(),
        }
    return render(request, "multiple/select_ex_perf.html", context)



def create_multiple_ex_perf(request):
    role = request.user.role
    if role and role.modules.filter(name='create_ex_perf_admin').exists():
        ex_perfs = ExPerfMultiple.objects.filter(submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_ex_perf_battalion').exists():
        companies = request.user.battalion.companies.all()
        ex_perfs = ExPerfMultiple.objects.filter(member__company__in=companies, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_ex_perf_company').exists():
        company = request.user.company
        ex_perfs = ExPerfMultiple.objects.filter(member__company=company, submit=False).order_by('member__rank')
    else:
        return render(request, 'others/no_permission.html')


    if request.method == "POST":
        for item in ex_perfs:
            member_id = item.member.id
            appt_held = request.POST.get(f"appt_held_{member_id}")
            remark = request.POST.get(f"remark_{member_id}")

            # Create Ex perf record
            ExPerf.objects.create(
                member=item.member,
                date_from=item.date_from,
                date_to=item.date_to,
                appt_held=appt_held,
                ex_perf_name=item.ex_perf_name,
                remark=remark,
            )
            item.submit = True
            item.save()
        messages.success(request, "Multiple Ex Performance created successfully.")
        return redirect("read_ex_perf")  # redirect to a success page


    context = {
        "ex_perfs": ex_perfs,
        "remarks":REMARK_LIST,
    }
    return render(request, "multiple/create_ex_perf.html", context)






# TODO: FD Firing
@login_required
def select_multiple_fd_firing(request):
    if request.method == "POST":
        date_from = request.POST.get("date_from")
        date_to = request.POST.get("date_to")
        range_id = request.POST.get("range")
        selected_members = request.POST.getlist("members")  # List of selected member IDs
        if not date_from or not date_to or not range_id:
            messages.error(request, "Please fill in all required fields.")
            return redirect("select_multiple_fd_firing")

        members_queryset = Member.objects.filter(id__in=selected_members)
        for member in members_queryset:
            FDFiringMultiple.objects.create(member=member,date_from=date_from,date_to=date_to,range_id=range_id)

        messages.success(request, "Multiple Fd Firing created successfully.")
        return redirect("create_multiple_fd_firing")

    role = request.user.role
    if role and role.modules.filter(name='create_fd_firing_admin').exists():
        members = Member.objects.filter(active=True).order_by('rank')
    elif role and role.modules.filter(name='create_fd_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        members = Member.objects.filter(active=True, company__in=companies).order_by('rank')
    elif role and role.modules.filter(name='create_fd_firing_company').exists():
        company = request.user.company
        members = Member.objects.filter(active=True, company=company).order_by('rank')
    else:
        return render(request, 'others/no_permission.html')
    

    context = {
        "members": members,
        "ranges": Range.objects.all(),
        }
    return render(request, "multiple/select_fd_firing.html", context)



def create_multiple_fd_firing(request):
    role = request.user.role
    if role and role.modules.filter(name='create_fd_firing_admin').exists():
        fd_firings = FDFiringMultiple.objects.filter(submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_fd_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        fd_firings = FDFiringMultiple.objects.filter(member__company__in=companies, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_fd_firing_company').exists():
        company = request.user.company
        fd_firings = FDFiringMultiple.objects.filter(member__company=company, submit=False).order_by('member__rank')
    else:
        return render(request, 'others/no_permission.html')


    if request.method == "POST":
        for item in fd_firings:
            member_id = item.member.id
            result = request.POST.get(f"result_{member_id}")
            score = request.POST.get(f"score_{member_id}")
            remark = request.POST.get(f"remark_{member_id}")
            reason = request.POST.get(f"reason_{member_id}")

            # Create PET record
            FDFiring.objects.create(
                member=item.member,
                date_from=item.date_from,
                date_to=item.date_to,
                range=item.range,
                result=result,
                score=score,
                remark=remark,
                reason=reason
            )
            item.submit = True
            item.save()
        messages.success(request, "Multiple Fd Firing created successfully.")
        return redirect("read_fd_firing")  # redirect to a success page


    context = {
        "fd_firings": fd_firings,
        "results":RESULT_LIST,
        "remarks":REMARK_LIST,
        "reasons":REASON_LIST,
    }
    return render(request, "multiple/create_fd_firing.html", context)




# TODO: Course Shooting
@login_required
def select_multiple_course_shooting(request):
    if request.method == "POST":
        date_from = request.POST.get("date_from")
        date_to = request.POST.get("date_to")
        range_id = request.POST.get("range")
        selected_members = request.POST.getlist("members")  # List of selected member IDs
        if not date_from or not date_to or not range_id:
            messages.error(request, "Please fill in all required fields.")
            return redirect("select_multiple_course_shooting")

        members_queryset = Member.objects.filter(id__in=selected_members)
        for member in members_queryset:
            CourseShootingMultiple.objects.create(member=member,date_from=date_from,date_to=date_to,range_id=range_id)

        messages.success(request, "Multiple Course Shooting created successfully.")
        return redirect("create_multiple_course_shooting")

    role = request.user.role
    if role and role.modules.filter(name='create_course_shooting_admin').exists():
        members = Member.objects.filter(active=True).order_by('rank')
    elif role and role.modules.filter(name='create_course_shooting_battalion').exists():
        companies = request.user.battalion.companies.all()
        members = Member.objects.filter(active=True, company__in=companies).order_by('rank')
    elif role and role.modules.filter(name='create_course_shooting_company').exists():
        company = request.user.company
        members = Member.objects.filter(active=True, company=company).order_by('rank')
    else:
        return render(request, 'others/no_permission.html')
    

    context = {
        "members": members,
        "ranges": Range.objects.all(),
        }
    return render(request, "multiple/select_course_shooting.html", context)



def create_multiple_course_shooting(request):
    role = request.user.role
    if role and role.modules.filter(name='create_course_shooting_admin').exists():
        course_shootings = CourseShootingMultiple.objects.filter(submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_course_shooting_battalion').exists():
        companies = request.user.battalion.companies.all()
        course_shootings = CourseShootingMultiple.objects.filter(member__company__in=companies, submit=False).order_by('member__rank')
    elif role and role.modules.filter(name='create_course_shooting_company').exists():
        company = request.user.company
        course_shootings = CourseShootingMultiple.objects.filter(member__company=company, submit=False).order_by('member__rank')
    else:
        return render(request, 'others/no_permission.html')


    if request.method == "POST":
        for item in course_shootings:
            member_id = item.member.id
            result = request.POST.get(f"result_{member_id}")
            score = request.POST.get(f"score_{member_id}")
            remark = request.POST.get(f"remark_{member_id}")
            reason = request.POST.get(f"reason_{member_id}")

            # Create PET record
            CourseShooting.objects.create(
                member=item.member,
                date_from=item.date_from,
                date_to=item.date_to,
                range=item.range,
                result=result,
                score=score,
                remark=remark,
                reason=reason
            )
            item.submit = True
            item.save()
        messages.success(request, "Multiple Fd Firing created successfully.")
        return redirect("read_course_shooting")  # redirect to a success page


    context = {
        "course_shootings": course_shootings,
        "results":RESULT_LIST,
        "remarks":REMARK_LIST,
        "reasons":REASON_LIST,
    }
    return render(request, "multiple/create_course_shooting.html", context)