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()
#for pdf
from django.template.loader import get_template
from django.http import HttpResponse
from xhtml2pdf import pisa
from .variable import *
from .custom_today import get_custom_today

today = datetime.today()

#TODO: Punishment
@login_required
def read_punishment(request):
    role = request.user.role
    if role and role.modules.filter(name='read_punishment_admin').exists():
        punishments = Punishment.objects.all().order_by('-date', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_punishment_battalion').exists():
        companies = request.user.battalion.companies.all()
        punishments = Punishment.objects.filter(member__company__in=companies).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_punishment_company').exists():
        company = request.user.company
        punishments = Punishment.objects.filter(member__company=company).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')


    punishment_types = PunishmentType.objects.all()
    punishment_names = PunishmentName.objects.all()
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        punishments = punishments.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)|
            Q(status__icontains=search_query)  
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        punishments = punishments.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        punishments = punishments.filter(member__company=company_query)
    # pagination for courseCdrTrg
    paginator = Paginator(punishments, 50)  # 50 records per page
    page_number = request.GET.get('page')
    punishments = paginator.get_page(page_number)
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "punishments":punishments,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "punishment_types":punishment_types,
        "punishment_names":punishment_names,
        "query_string":query_string,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",

    }
    return render(request,'performance/read_punishment.html',context)

@login_required
def create_punishment(request):
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        punishment_type_id = request.POST.get('punishment_type')
        punishment_name_id = request.POST.get('punishment_name')
        date = request.POST.get('date')
        remarks = request.POST.get('remarks')
        # Check if all fields are provided
        if not all([army_no,punishment_type_id,date,punishment_type_id]):
            messages.error(request, "All fields are required")
            return redirect('read_punishment')
        
        
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='create_punishment_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_punishment')
        elif role and role.modules.filter(name='create_punishment_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_punishment')
        elif role and role.modules.filter(name='create_punishment_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_punishment')
        else:
            return render(request, 'others/no_permission.html')
        
        
        member = Member.objects.get(army_no=army_no)
        try:
            punishment = Punishment.objects.create(member=member,punishment_type_id=punishment_type_id,punishment_name_id=punishment_name_id,date=date,remarks=remarks)
            messages.success(request, f"✅ {member.name} has been added to Punishment")
            return redirect('read_punishment')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_punishment')   
    return redirect('read_punishment')

@login_required
def delete_punishment(request,id):
    punishment = Punishment.objects.get(id=id)
    member = punishment.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='delete_punishment_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_punishment')
    elif role and role.modules.filter(name='delete_punishment_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_punishment')
    elif role and role.modules.filter(name='delete_punishment_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_punishment')
    else:
        return render(request, 'others/no_permission.html')
    # delete punishment
    punishment.delete()
    return redirect('read_punishment')






#TODO: Promotion
@login_required
def read_promotion(request):
    role = request.user.role
    if role and role.modules.filter(name='read_promotion_admin').exists():
        promotions = Promotion.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_promotion_battalion').exists():
        companies = request.user.battalion.companies.all()
        promotions = Promotion.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_promotion_company').exists():
        company = request.user.company
        promotions = Promotion.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        promotions = promotions.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        promotions = promotions.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        promotions = promotions.filter(member__company=company_query)
        
        
    # pagination for courseCdrTrg
    paginator = Paginator(promotions, 50)  # 50 records per page
    page_number = request.GET.get('page')
    promotions = paginator.get_page(page_number)
    
    promotion_types = PromotionType.objects.all()
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "promotions":promotions,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "promotion_types":promotion_types,
        "query_string":query_string,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_promotion.html',context)


@login_required
def create_promotion(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        promotion_type_id = request.POST.get('promotion_type')
        remarks = request.POST.get('remarks')
        # Check if all fields are provided
        if not all([army_no,date,promotion_type_id]):
            messages.error(request, "All fields are required")
            return redirect('read_promotion')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_promotion_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_promotion')
        elif role and role.modules.filter(name='read_promotion_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_promotion')
        elif role and role.modules.filter(name='read_promotion_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_promotion')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        promotion_type = PromotionType.objects.get(id=promotion_type_id) if promotion_type_id else None
        try:
            promotion = Promotion.objects.create(member=member,date=date)
            promotion.promotion_type = promotion_type
            promotion.remarks = remarks
            promotion.save()
            messages.success(request, f"✅ {member.name} has been added to Promotion")
            return redirect('read_promotion')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_promotion')   
    return redirect('read_promotion')


@login_required
def delete_promotion(request,id):
    promotion = Promotion.objects.get(id=id)
    member = promotion.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_promotion_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_promotion')
    elif role and role.modules.filter(name='read_promotion_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_promotion')
    elif role and role.modules.filter(name='read_promotion_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_promotion')
    else:
        return render(request, 'others/no_permission.html')
    # delete promotion
    promotion.delete()
    return redirect('read_promotion')



#TODO: Demotion
@login_required
def read_demotion(request):
    role = request.user.role
    if role and role.modules.filter(name='read_demotion_admin').exists():
        demotions = Demotion.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_demotion_battalion').exists():
        companies = request.user.battalion.companies.all()
        demotions = Demotion.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_demotion_company').exists():
        company = request.user.company
        demotions = Demotion.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        demotions = demotions.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        demotions = demotions.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        demotions = demotions.filter(member__company=company_query)
        
        
    # pagination for courseCdrTrg
    paginator = Paginator(demotions, 50)  # 50 records per page
    page_number = request.GET.get('page')
    demotions = paginator.get_page(page_number)
    
    demotion_types = DemotionType.objects.all()
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "demotions":demotions,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "demotion_types":demotion_types,
        "query_string":query_string,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_demotion.html',context)


@login_required
def create_demotion(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        demotion_type_id = request.POST.get('demotion_type')
        remarks = request.POST.get('remarks')
        # Check if all fields are provided
        if not all([army_no,date,demotion_type_id]):
            messages.error(request, "All fields are required")
            return redirect('read_demotion')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_demotion_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_demotion')
        elif role and role.modules.filter(name='read_demotion_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_demotion')
        elif role and role.modules.filter(name='read_demotion_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_demotion')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        demotion_type = DemotionType.objects.get(id=demotion_type_id) if demotion_type_id else None
        try:
            demotion = Demotion.objects.create(member=member,date=date)
            demotion.demotion_type = demotion_type
            demotion.remarks = remarks
            demotion.save()
            messages.success(request, f"✅ {member.name} has been added to Demotion")
            return redirect('read_demotion')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_demotion')   
    return redirect('read_demotion')


@login_required
def delete_demotion(request,id):
    demotion = Demotion.objects.get(id=id)
    member = demotion.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_demotion_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_demotion')
    elif role and role.modules.filter(name='read_demotion_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_demotion')
    elif role and role.modules.filter(name='read_demotion_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_demotion')
    else:
        return render(request, 'others/no_permission.html')
    # delete demotion
    demotion.delete()
    return redirect('read_demotion')



#TODO: PET
@login_required
def read_pet(request):
    role = request.user.role
    if role and role.modules.filter(name='read_pet_admin').exists():
        pets = PET.objects.all().order_by('-date', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_pet_battalion').exists():
        companies = request.user.battalion.companies.all()
        pets = PET.objects.filter(member__company__in=companies).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_pet_company').exists():
        company = request.user.company
        pets = PET.objects.filter(member__company=company).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        pets = pets.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        pets = pets.filter(member__company=company_query)
    
    # get by_annual
    by_annual = request.GET.get('by_annual', '')
    if by_annual:
        pets = pets.filter(by_annual=by_annual)
    # get result
    result = request.GET.get('result', '')
    if result:
        pets = pets.filter(result=result)
    
    year = request.GET.get('year', today.year)
    if year:
        pets = pets.filter(date__year=year)
        
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        pets = pets.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    # pagination for courseCdrTrg
    paginator = Paginator(pets, 50)  # 50 records per page
    page_number = request.GET.get('page')
    pets = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "pets":pets,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "by_annuals":BY_ANNUAL_LIST,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "remarks":REMARK_LIST,
        "reasons":REASON_LIST,
        "by_annual": int(by_annual) if by_annual else "",
        "result":result,
        "year":year,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_pet.html',context)


@login_required
def create_pet(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        by_annual = request.POST.get('by_annual')
        result = request.POST.get('result')
        attempt = request.POST.get('attempt')
        remark = request.POST.get('remark')
        reason = request.POST.get('reason')
        auth = request.POST.get('auth')

        # Check if all fields are provided
        if not all([army_no,result]):
            messages.error(request, "All fields are required")
            return redirect('read_pet')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_pet_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_pet')
        elif role and role.modules.filter(name='read_pet_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_pet')
        elif role and role.modules.filter(name='read_pet_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_pet')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            PET.objects.create(member=member,date=date,by_annual=by_annual,result=result,attempt=attempt,auth=auth,remark=remark,reason=reason)
            messages.success(request, f"✅ {member.name} has been added to PET")
            return redirect('read_pet')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_pet')   
    return redirect('read_pet')


@login_required
def delete_pet(request,id):
    pet = PET.objects.get(id=id)
    member = pet.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_pet_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_pet')
    elif role and role.modules.filter(name='read_pet_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_pet')
    elif role and role.modules.filter(name='read_pet_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_pet')
    else:
        return render(request, 'others/no_permission.html')
    # delete pet
    pet.delete()
    return redirect('read_pet')




#TODO: RET
@login_required
def read_ret(request):
    role = request.user.role
    if role and role.modules.filter(name='read_ret_admin').exists():
        rets = RET.objects.all().order_by('-date', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_ret_battalion').exists():
        companies = request.user.battalion.companies.all()
        rets = RET.objects.filter(member__company__in=companies).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_ret_company').exists():
        company = request.user.company
        rets = RET.objects.filter(member__company=company).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        rets = rets.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        rets = rets.filter(member__company=company_query)
    
    
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        rets = rets.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query) 
        )
    # Get result query
    result = request.GET.get("result", "")
    if result:
        rets = rets.filter(result=result)
    # Get ret query
    ret = request.GET.get("ret", "")
    if ret:
        rets = rets.filter(ret=ret)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        rets = rets.filter(date__year=year)
    
    # pagination for courseCdrTrg
    paginator = Paginator(rets, 50)  # 50 records per page
    page_number = request.GET.get('page')
    rets = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "rets":rets,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "gps":GP_LIST,
        "reasons":REASON_LIST,
        "remarks":REMARK_LIST,
        "ret_choices":Yes_No,
        "result":int(result) if result else "",
        "ret":int(ret) if ret else "",
        "year":year,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_ret.html',context)


@login_required
def create_ret(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        result = request.POST.get('result')
        attempt = request.POST.get('attempt')
        gp = request.POST.get('gp')
        reason = request.POST.get('reason')
        remark = request.POST.get('remark')
        hit = request.POST.get('hit') or None
        total = request.POST.get('total') or None
        ret = request.POST.get('ret')
        
        auth = request.POST.get('auth')

        # Check if all fields are provided
        if not all([army_no,date,result]):
            messages.error(request, "All fields are required")
            return redirect('read_ret')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_ret_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_ret')
        elif role and role.modules.filter(name='read_ret_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_ret')
        elif role and role.modules.filter(name='read_ret_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_ret')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            RET.objects.create(member=member,date=date,result=result,attempt=attempt,auth=auth,gp=gp,reason=reason,remark=remark,hit=hit,total=total,ret=ret)
            messages.success(request, f"✅ {member.name} has been added to RET")
            return redirect('read_ret')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_ret')   
    return redirect('read_ret')


@login_required
def delete_ret(request,id):
    ret = RET.objects.get(id=id)
    member = ret.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_ret_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_ret')
    elif role and role.modules.filter(name='read_ret_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_ret')
    elif role and role.modules.filter(name='read_ret_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_ret')
    else:
        return render(request, 'others/no_permission.html')
    # delete ret
    ret.delete()
    return redirect('read_ret')


#TODO: GR Firing
@login_required
def read_gr_firing(request):
    role = request.user.role
    if role and role.modules.filter(name='read_gr_firing_admin').exists():
        gr_firings = GRFiring.objects.all().order_by('-date', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_gr_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        gr_firings = GRFiring.objects.filter(member__company__in=companies).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_gr_firing_company').exists():
        company = request.user.company
        gr_firings = GRFiring.objects.filter(member__company=company).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    #get battalion
    battalion_query = request.GET.get('battalion_query')
    if battalion_query:
        gr_firings = gr_firings.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query')
    if company_query:
        gr_firings = gr_firings.filter(member__company=company_query)
    
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        gr_firings = gr_firings.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    # Get result query
    result = request.GET.get("result", "")
    if result:
        gr_firings = gr_firings.filter(result=result)
        
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        gr_firings = gr_firings.filter(date__year=year)
    
    # pagination for courseCdrTrg
    paginator = Paginator(gr_firings, 50)  # 50 records per page
    page_number = request.GET.get('page')
    gr_firings = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "gr_firings":gr_firings,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "reasons":REASON_LIST,
        "remarks":REMARK_LIST,
        "result":int(result) if result else "",
        "year":year,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_gr_firing.html',context)


@login_required
def create_gr_firing(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        attempt = request.POST.get('attempt')
        result = request.POST.get('result')
        remark = request.POST.get('remark')
        reason = request.POST.get('reason')
        auth = request.POST.get('auth')
        total = request.POST.get('total') or None

        # Check if all fields are provided
        if not all([army_no,date,result]):
            messages.error(request, "All fields are required")
            return redirect('read_gr_firing')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_gr_firing_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_gr_firing')
        elif role and role.modules.filter(name='read_gr_firing_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_gr_firing')
        elif role and role.modules.filter(name='read_gr_firing_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_gr_firing')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            GRFiring.objects.create(member=member,date=date,attempt=attempt,auth=auth,result=result,remark=remark,reason=reason,total=total)
            messages.success(request, f"✅ {member.name} has been added to GRFiring")
            return redirect('read_gr_firing')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_gr_firing')   
    return redirect('read_gr_firing')


@login_required
def delete_gr_firing(request,id):
    gr_firing = GRFiring.objects.get(id=id)
    member = gr_firing.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_gr_firing_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_gr_firing')
    elif role and role.modules.filter(name='read_gr_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_gr_firing')
    elif role and role.modules.filter(name='read_gr_firing_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_gr_firing')
    else:
        return render(request, 'others/no_permission.html')
    # delete gr_firing
    gr_firing.delete()
    return redirect('read_gr_firing')



#TODO: SM
@login_required
def read_sm(request):
    role = request.user.role
    if role and role.modules.filter(name='read_sm_admin').exists():
        sms = SM.objects.all().order_by('-date', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_sm_battalion').exists():
        companies = request.user.battalion.companies.all()
        sms = SM.objects.filter(member__company__in=companies).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_sm_company').exists():
        company = request.user.company
        sms = SM.objects.filter(member__company=company).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        sms = sms.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        sms = sms.filter(member__company=company_query)
    
    # Get result query
    result = request.GET.get("result", "")
    if result:
        sms = sms.filter(result=result)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        sms = sms.filter(date__year=year)
        
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        sms = sms.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    # pagination for courseCdrTrg
    paginator = Paginator(sms, 50)  # 50 records per page
    page_number = request.GET.get('page')
    sms = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "sms":sms,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "reasons":REASON_LIST,
        "remarks":REMARK_LIST,
        "result":int(result) if result else "",
        "year":year,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_sm.html',context)


@login_required
def create_sm(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        result = request.POST.get('result')
        attempt = request.POST.get('attempt')
        remark = request.POST.get('remark')
        reason = request.POST.get('reason')

        # Check if all fields are provided
        if not all([army_no,date,result]):
            messages.error(request, "All fields are required")
            return redirect('read_sm')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_sm_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_sm')
        elif role and role.modules.filter(name='read_sm_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_sm')
        elif role and role.modules.filter(name='read_sm_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_sm')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            SM.objects.create(member=member,date=date,result=result,attempt=attempt,remark=remark,reason=reason)
            messages.success(request, f"✅ {member.name} has been added to SM")
            return redirect('read_sm')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_sm')   
    return redirect('read_sm')


@login_required
def delete_sm(request,id):
    sm = SM.objects.get(id=id)
    member = sm.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_sm_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_sm')
    elif role and role.modules.filter(name='read_sm_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_sm')
    elif role and role.modules.filter(name='read_sm_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_sm')
    else:
        return render(request, 'others/no_permission.html')
    # delete sm
    sm.delete()
    return redirect('read_sm')


#TODO: AsltCourse
@login_required
def read_aslt_course(request):
    role = request.user.role
    if role and role.modules.filter(name='read_aslt_course_admin').exists():
        aslt_courses = AsltCourse.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_aslt_course_battalion').exists():
        companies = request.user.battalion.companies.all()
        aslt_courses = AsltCourse.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_aslt_course_company').exists():
        company = request.user.company
        aslt_courses = AsltCourse.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        aslt_courses = aslt_courses.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        aslt_courses = aslt_courses.filter(member__company=company_query)
    
    # Get result query
    result = request.GET.get("result", "")
    if result:
        aslt_courses = aslt_courses.filter(result=result)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        aslt_courses = aslt_courses.filter(date__year=year)
        
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        aslt_courses = aslt_courses.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    # pagination for courseCdrTrg
    paginator = Paginator(aslt_courses, 50)  # 50 records per page
    page_number = request.GET.get('page')
    aslt_courses = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "aslt_courses":aslt_courses,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "results":RESULT_LIST,
        "attempts":ATTEMPT_LIST,
        "reasons":REASON_LIST,
        "remarks":REMARK_LIST,
        "result":int(result) if result else "",
        "year":year,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_aslt_course.html',context)


@login_required
def create_aslt_course(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        result = request.POST.get('result')
        attempt = request.POST.get('attempt')
        remark = request.POST.get('remark')
        reason = request.POST.get('reason')

        # Check if all fields are provided
        if not all([army_no,date,result]):
            messages.error(request, "All fields are required")
            return redirect('read_aslt_course')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_aslt_course_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_aslt_course')
        elif role and role.modules.filter(name='read_aslt_course_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_aslt_course')
        elif role and role.modules.filter(name='read_aslt_course_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_aslt_course')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            AsltCourse.objects.create(member=member,date=date,result=result,attempt=attempt,remark=remark,reason=reason)
            messages.success(request, f"✅ {member.name} has been added to AsltCourse")
            return redirect('read_aslt_course')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_aslt_course')   
    return redirect('read_aslt_course')


@login_required
def delete_aslt_course(request,id):
    aslt_course = AsltCourse.objects.get(id=id)
    member = aslt_course.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_aslt_course_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_aslt_course')
    elif role and role.modules.filter(name='read_aslt_course_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_aslt_course')
    elif role and role.modules.filter(name='read_aslt_course_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_aslt_course')
    else:
        return render(request, 'others/no_permission.html')
    # delete aslt_course
    aslt_course.delete()
    return redirect('read_aslt_course')



#TODO: FDFiring
@login_required
def read_fd_firing(request):
    role = request.user.role
    if role and role.modules.filter(name='read_fd_firing_admin').exists():
        fd_firings = FDFiring.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_fd_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        fd_firings = FDFiring.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_fd_firing_company').exists():
        company = request.user.company
        fd_firings = FDFiring.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    #get battalion
    battalion_query = request.GET.get('battalion_query')
    if battalion_query:
        fd_firings = fd_firings.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query')
    if company_query:
        fd_firings = fd_firings.filter(member__company=company_query)
    
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        fd_firings = fd_firings.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    # Get result query
    result = request.GET.get("result", "")
    if result:
        fd_firings = fd_firings.filter(result=result)
        
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        fd_firings = fd_firings.filter(date_from__year=year)
    
    # pagination for courseCdrTrg
    paginator = Paginator(fd_firings, 50)  # 50 records per page
    page_number = request.GET.get('page')
    fd_firings = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "fd_firings":fd_firings,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "results":RESULT_LIST,
        "ranges":Range.objects.all().order_by('text'),
        "reasons":REASON_LIST,
        "remarks":REMARK_LIST,
        "result":int(result) if result else "",
        "year":year,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_fd_firing.html',context)


@login_required
def create_fd_firing(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date_from = request.POST.get('date_from')
        date_to = request.POST.get('date_to')
        range_id = request.POST.get('range')
        result = request.POST.get('result')
        remark = request.POST.get('remark')
        reason = request.POST.get('reason')
        score = request.POST.get('total') or None

        # Check if all fields are provided
        if not all([army_no,date_to,date_from,result]):
            messages.error(request, "All fields are required")
            return redirect('read_fd_firing')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_fd_firing_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_fd_firing')
        elif role and role.modules.filter(name='read_fd_firing_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_fd_firing')
        elif role and role.modules.filter(name='read_fd_firing_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_fd_firing')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            FDFiring.objects.create(member=member,date_to=date_to,date_from=date_from,range_id=range_id,result=result,remark=remark,reason=reason,score=score)
            messages.success(request, f"✅ {member.name} has been added to FDFiring")
            return redirect('read_fd_firing')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_fd_firing')   
    return redirect('read_fd_firing')


@login_required
def delete_fd_firing(request,id):
    fd_firing = FDFiring.objects.get(id=id)
    member = fd_firing.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_fd_firing_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_fd_firing')
    elif role and role.modules.filter(name='read_fd_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_fd_firing')
    elif role and role.modules.filter(name='read_fd_firing_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_fd_firing')
    else:
        return render(request, 'others/no_permission.html')
    # delete fd_firing
    fd_firing.delete()
    return redirect('read_fd_firing')



#TODO: CourseShooting
@login_required
def read_course_shooting(request):
    role = request.user.role
    if role and role.modules.filter(name='read_course_shooting_admin').exists():
        course_shootings = CourseShooting.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_course_shooting_battalion').exists():
        companies = request.user.battalion.companies.all()
        course_shootings = CourseShooting.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_course_shooting_company').exists():
        company = request.user.company
        course_shootings = CourseShooting.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    #get battalion
    battalion_query = request.GET.get('battalion_query')
    if battalion_query:
        course_shootings = course_shootings.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query')
    if company_query:
        course_shootings = course_shootings.filter(member__company=company_query)
    
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        course_shootings = course_shootings.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    # Get result query
    result = request.GET.get("result", "")
    if result:
        course_shootings = course_shootings.filter(result=result)
        
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        course_shootings = course_shootings.filter(date_from__year=year)
    
    # pagination for courseCdrTrg
    paginator = Paginator(course_shootings, 50)  # 50 records per page
    page_number = request.GET.get('page')
    course_shootings = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "course_shootings":course_shootings,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "results":RESULT_LIST,
        "ranges":Range.objects.all().order_by('text'),
        "reasons":REASON_LIST,
        "remarks":REMARK_LIST,
        "result":int(result) if result else "",
        "year":year,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_course_shooting.html',context)


@login_required
def create_course_shooting(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date_from = request.POST.get('date_from')
        date_to = request.POST.get('date_to')
        range_id = request.POST.get('range')
        result = request.POST.get('result')
        remark = request.POST.get('remark')
        reason = request.POST.get('reason')
        score = request.POST.get('total') or None

        # Check if all fields are provided
        if not all([army_no,date_to,date_from,result]):
            messages.error(request, "All fields are required")
            return redirect('read_course_shooting')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_course_shooting_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_course_shooting')
        elif role and role.modules.filter(name='read_course_shooting_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_course_shooting')
        elif role and role.modules.filter(name='read_course_shooting_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_course_shooting')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            CourseShooting.objects.create(member=member,date_to=date_to,date_from=date_from,range_id=range_id,result=result,remark=remark,reason=reason,score=score)
            messages.success(request, f"✅ {member.name} has been added to CourseShooting")
            return redirect('read_course_shooting')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_course_shooting')   
    return redirect('read_course_shooting')


@login_required
def delete_course_shooting(request,id):
    course_shooting = CourseShooting.objects.get(id=id)
    member = course_shooting.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_course_shooting_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_course_shooting')
    elif role and role.modules.filter(name='read_course_shooting_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_course_shooting')
    elif role and role.modules.filter(name='read_course_shooting_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_course_shooting')
    else:
        return render(request, 'others/no_permission.html')
    # delete course_shooting
    course_shooting.delete()
    return redirect('read_course_shooting')






#TODO: ExPerf
@login_required
def read_ex_perf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_ex_perf_admin').exists():
        ex_perfs = ExPerf.objects.all().order_by('-date_from', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_ex_perf_battalion').exists():
        companies = request.user.battalion.companies.all()
        ex_perfs = ExPerf.objects.filter(member__company__in=companies).order_by('-date_from', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_ex_perf_company').exists():
        company = request.user.company
        ex_perfs = ExPerf.objects.filter(member__company=company).order_by('-date_from', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')


    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        ex_perfs = ex_perfs.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        ex_perfs = ex_perfs.filter(member__company=company_query)
    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        ex_perfs = ex_perfs.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    ex_perf_name = request.GET.get("ex_perf_name", "")
    if ex_perf_name:
        ex_perfs = ex_perfs.filter(ex_perf_name=ex_perf_name)
        
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        ex_perfs = ex_perfs.filter(date_from__year=year)
    else:
        ex_perfs = ex_perfs.filter(date_from__year=today.year)
        year = today.year
        
        
    # pagination for courseCdrTrg
    paginator = Paginator(ex_perfs, 50)  # 50 records per page
    page_number = request.GET.get('page')
    ex_perfs = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "ex_perfs":ex_perfs,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "ex_perf_names":ExPerfName.objects.all(),
        "remarks":REMARK_LIST,
        "ex_perf_name":int(ex_perf_name) if ex_perf_name else "",
        "year":year,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_ex_perf.html',context)


@login_required
def create_ex_perf(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date_from = request.POST.get('date_from')
        date_to = request.POST.get('date_to')
        remark = request.POST.get('remark')
        appt_held = request.POST.get('appt_held')
        ex_perf_name = request.POST.get('ex_perf_name')
        

        # Check if all fields are provided
        if not all([army_no,date_from,date_to]):
            messages.error(request, "All fields are required")
            return redirect('read_ex_perf')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_ex_perf_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_ex_perf')
        elif role and role.modules.filter(name='read_ex_perf_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_ex_perf')
        elif role and role.modules.filter(name='read_ex_perf_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_ex_perf')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            ExPerf.objects.create(member=member,date_to=date_to,date_from=date_from,remark=remark,appt_held=appt_held,ex_perf_name_id=ex_perf_name)
            messages.success(request, f"✅ {member.name} has been added to ExPerf")
            return redirect('read_ex_perf')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_ex_perf')   
    return redirect('read_ex_perf')


@login_required
def delete_ex_perf(request,id):
    ex_perf = ExPerf.objects.get(id=id)
    member = ex_perf.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_ex_perf_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_ex_perf')
    elif role and role.modules.filter(name='read_ex_perf_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_ex_perf')
    elif role and role.modules.filter(name='read_ex_perf_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_ex_perf')
    else:
        return render(request, 'others/no_permission.html')
    # delete ex_perf
    ex_perf.delete()
    return redirect('read_ex_perf')




#TODO: Observation
@login_required
def read_observation(request):
    role = request.user.role
    if role and role.modules.filter(name='read_observation_admin').exists():
        observations = Observation.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_observation_battalion').exists():
        companies = request.user.battalion.companies.all()
        observations = Observation.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_observation_company').exists():
        company = request.user.company
        observations = Observation.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        observations = observations.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        observations = observations.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        observations = observations.filter(member__company=company_query)
        
        
    # pagination for courseCdrTrg
    paginator = Paginator(observations, 50)  # 50 records per page
    page_number = request.GET.get('page')
    observations = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "observations":observations,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_observation.html',context)


@login_required
def create_observation(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        remarks = request.POST.get('remarks')
        # Check if all fields are provided
        if not all([army_no,date,remarks]):
            messages.error(request, "All fields are required")
            return redirect('read_observation')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_observation_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_observation')
        elif role and role.modules.filter(name='read_observation_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_observation')
        elif role and role.modules.filter(name='read_observation_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_observation')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            observation = Observation.objects.create(member=member,date=date)
            observation.remarks = remarks
            observation.save()
            messages.success(request, f"✅ {member.name} has been added to Observation")
            return redirect('read_observation')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_observation')   
    return redirect('read_observation')


@login_required
def delete_observation(request,id):
    observation = Observation.objects.get(id=id)
    member = observation.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_observation_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_observation')
    elif role and role.modules.filter(name='read_observation_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_observation')
    elif role and role.modules.filter(name='read_observation_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_observation')
    else:
        return render(request, 'others/no_permission.html')
    # delete observation
    observation.delete()
    return redirect('read_observation')



#TODO: Reward
@login_required
def read_reward(request):
    role = request.user.role
    if role and role.modules.filter(name='read_reward_admin').exists():
        rewards = Reward.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_reward_battalion').exists():
        companies = request.user.battalion.companies.all()
        rewards = Reward.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_reward_company').exists():
        company = request.user.company
        rewards = Reward.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        rewards = rewards.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        rewards = rewards.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        rewards = rewards.filter(member__company=company_query)
        
        
    # pagination for courseCdrTrg
    paginator = Paginator(rewards, 50)  # 50 records per page
    page_number = request.GET.get('page')
    rewards = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "rewards":rewards,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
    }
    return render(request,'performance/read_reward.html',context)


@login_required
def create_reward(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        remarks = request.POST.get('remarks')
        # Check if all fields are provided
        if not all([army_no,date,remarks]):
            messages.error(request, "All fields are required")
            return redirect('read_reward')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_reward_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_reward')
        elif role and role.modules.filter(name='read_reward_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_reward')
        elif role and role.modules.filter(name='read_reward_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_reward')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            reward = Reward.objects.create(member=member,date=date)
            reward.remarks = remarks
            reward.save()
            messages.success(request, f"✅ {member.name} has been added to Reward")
            return redirect('read_reward')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_reward')   
    return redirect('read_reward')


@login_required
def delete_reward(request,id):
    reward = Reward.objects.get(id=id)
    member = reward.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_reward_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_reward')
    elif role and role.modules.filter(name='read_reward_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_reward')
    elif role and role.modules.filter(name='read_reward_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_reward')
    else:
        return render(request, 'others/no_permission.html')
    # delete reward
    reward.delete()
    return redirect('read_reward')




#TODO: Deserter
@login_required
def read_deserter(request):
    role = request.user.role
    if role and role.modules.filter(name='read_deserter_admin').exists():
        deserters = Deserter.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_deserter_battalion').exists():
        companies = request.user.battalion.companies.all()
        deserters = Deserter.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_deserter_company').exists():
        company = request.user.company
        deserters = Deserter.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        deserters = deserters.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        deserters = deserters.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        deserters = deserters.filter(member__company=company_query)
    
    year = request.GET.get('year', today.year)
    if year:
        deserters = deserters.filter(date__year=year)
        
        
    # pagination for courseCdrTrg
    paginator = Paginator(deserters, 50)  # 50 records per page
    page_number = request.GET.get('page')
    deserters = paginator.get_page(page_number)
    
    
    # get the current page number with query string
    query_dict = request.GET.copy()
    if 'page' in query_dict:
        query_dict.pop('page')
    query_string = query_dict.urlencode()
    context = {
        "deserters":deserters,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "query_string":query_string,
        "battalions":Battalion.objects.all(),
        "battalion_query":int(battalion_query) if battalion_query else "",
        "company_query":int(company_query) if company_query else "",
        "year":year,
    }
    return render(request,'performance/read_deserter.html',context)


@login_required
def create_deserter(request):
    company = request.user.company
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        date = request.POST.get('date')
        remarks = request.POST.get('remarks')
        # Check if all fields are provided
        if not all([army_no,date,remarks]):
            messages.error(request, "All fields are required")
            return redirect('read_deserter')
        # Check if the member exists
        role = request.user.role
        if role and role.modules.filter(name='read_deserter_admin').exists():
            if not Member.objects.filter(army_no=army_no).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_deserter')
        elif role and role.modules.filter(name='read_deserter_battalion').exists():
            companies = request.user.battalion.companies.all()
            if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_deserter')
        elif role and role.modules.filter(name='read_deserter_company').exists():
            company = request.user.company
            if not Member.objects.filter(army_no=army_no, company=company).exists():
                messages.error(request, "Member does not exist")
                return redirect('read_deserter')
        else:
            return render(request, 'others/no_permission.html')
        member = Member.objects.get(army_no=army_no)
        try:
            deserter = Deserter.objects.create(member=member,date=date)
            deserter.remarks = remarks
            deserter.save()
            messages.success(request, f"✅ {member.name} has been added to Deserter")
            return redirect('read_deserter')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_deserter')   
    return redirect('read_deserter')


@login_required
def delete_deserter(request,id):
    deserter = Deserter.objects.get(id=id)
    member = deserter.member
    # Check if the member exists
    role = request.user.role
    if role and role.modules.filter(name='read_deserter_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_deserter')
    elif role and role.modules.filter(name='read_deserter_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_deserter')
    elif role and role.modules.filter(name='read_deserter_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_deserter')
    else:
        return render(request, 'others/no_permission.html')
    # delete deserter
    deserter.delete()
    messages.success(request, "Deserter deleted successfully.")
    return redirect('read_deserter')







# TODO: PDF
# punishment
@login_required
def read_punishment_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_punishment_admin').exists():
        punishments = Punishment.objects.all().order_by('-date', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_punishment_battalion').exists():
        companies = request.user.battalion.companies.all()
        punishments = Punishment.objects.filter(member__company__in=companies).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_punishment_company').exists():
        company = request.user.company
        punishments = Punishment.objects.filter(member__company=company).order_by('-date', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')


    punishment_types = PunishmentType.objects.all()
    punishment_names = PunishmentName.objects.all()
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        punishments = punishments.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)|
            Q(status__icontains=search_query)  
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        punishments = punishments.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        punishments = punishments.filter(member__company=company_query)
        
    context = {
        "punishments":punishments,
        "name":"Punishments"

    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_punishment_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Punishment.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response

# promotion
@login_required
def read_promotion_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_promotion_admin').exists():
        promotions = Promotion.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_promotion_battalion').exists():
        companies = request.user.battalion.companies.all()
        promotions = Promotion.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_promotion_company').exists():
        company = request.user.company
        promotions = Promotion.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        promotions = promotions.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        promotions = promotions.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        promotions = promotions.filter(member__company=company_query)
        
        
    context = {
        "promotions":promotions,
        "name":"Promotions"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_promotion_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Promotion.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response

# demotion
@login_required
def read_demotion_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_demotion_admin').exists():
        demotions = Demotion.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_demotion_battalion').exists():
        companies = request.user.battalion.companies.all()
        demotions = Demotion.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_demotion_company').exists():
        company = request.user.company
        demotions = Demotion.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        demotions = demotions.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        demotions = demotions.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        demotions = demotions.filter(member__company=company_query)
        
        
    
    context = {
        "demotions":demotions,
        "name":"Demotions"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_demotion_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Demotion.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response


# pet
@login_required
def read_pet_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_pet_admin').exists():
        pets = PET.objects.all().order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_pet_battalion').exists():
        companies = request.user.battalion.companies.all()
        pets = PET.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_pet_company').exists():
        company = request.user.company
        pets = PET.objects.filter(member__company=company).order_by('-created_at', '-id')
    else:
        return render(request, 'others/no_permission.html')

    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        pets = pets.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        pets = pets.filter(member__company=company_query)
    # get by_annual
    by_annual = request.GET.get('by_annual', '')
    if by_annual:
        pets = pets.filter(by_annual=by_annual)
    # get result
    result = request.GET.get('result', '')
    if result:
        pets = pets.filter(result=result)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        pets = pets.filter(date__year=year)
        
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        pets = pets.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    
    context = {
        "pets": pets,
        "name" : f"PET"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_pet_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="PET.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response


# ret
@login_required
def read_ret_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_ret_admin').exists():
        rets = RET.objects.all().order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_ret_battalion').exists():
        companies = request.user.battalion.companies.all()
        rets = RET.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_ret_company').exists():
        company = request.user.company
        rets = RET.objects.filter(member__company=company).order_by('-created_at', '-id')
    else:
        return render(request, 'others/no_permission.html')

    
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        rets = rets.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query) 
        )
    # Get result query
    result = request.GET.get("result", "")
    if result:
        rets = rets.filter(result=result)
    # Get ret query
    ret = request.GET.get("ret", "")
    if ret:
        rets = rets.filter(ret=ret)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        rets = rets.filter(date__year=year)
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        rets = rets.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        rets = rets.filter(member__company=company_query)
        
    context = {
        "rets": rets,
        "name" : f"RET"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_ret_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="RET.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response



# gr_firing
@login_required
def read_gr_firing_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_gr_firing_admin').exists():
        gr_firings = GRFiring.objects.all().order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_gr_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        gr_firings = GRFiring.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_gr_firing_company').exists():
        company = request.user.company
        gr_firings = GRFiring.objects.filter(member__company=company).order_by('-created_at', '-id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    # Get result query
    result = request.GET.get("result", "")
    if result:
        gr_firings = gr_firings.filter(result=result)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        gr_firings = gr_firings.filter(date__year=year)
        
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        gr_firings = gr_firings.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        gr_firings = gr_firings.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        gr_firings = gr_firings.filter(member__company=company_query)
    
    context = {
        "gr_firings": gr_firings,
        "name" : f"GR Firing"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_gr_firing_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="GR_Firing.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response


# sm
@login_required
def read_sm_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_sm_admin').exists():
        sms = SM.objects.all().order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_sm_battalion').exists():
        companies = request.user.battalion.companies.all()
        sms = SM.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_sm_company').exists():
        company = request.user.company
        sms = SM.objects.filter(member__company=company).order_by('-created_at', '-id')
    else:
        return render(request, 'others/no_permission.html')

    
    # Get result query
    result = request.GET.get("result", "")
    if result:
        sms = sms.filter(result=result)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        sms = sms.filter(date__year=year)
    
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        sms = sms.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        sms = sms.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        sms = sms.filter(member__company=company_query)
    
    context = {
        "sms": sms,
        "name" : f"Speed March"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_sm_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="speed_march.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response

# ex_perf
@login_required
def read_ex_perf_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_ex_perf_admin').exists():
        ex_perfs = ExPerf.objects.all().order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_ex_perf_battalion').exists():
        companies = request.user.battalion.companies.all()
        ex_perfs = ExPerf.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_ex_perf_company').exists():
        company = request.user.company
        ex_perfs = ExPerf.objects.filter(member__company=company).order_by('-created_at', '-id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        ex_perfs = ex_perfs.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    ex_perf_name = request.GET.get("ex_perf_name", "")
    if ex_perf_name:
        ex_perfs = ex_perfs.filter(ex_perf_name_id=ex_perf_name)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        ex_perfs = ex_perfs.filter(date_from__year=year)    
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        ex_perfs = ex_perfs.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        ex_perfs = ex_perfs.filter(member__company=company_query)
     
    
    context = {
        "ex_perfs": ex_perfs,
        "name" : f"Ex Performance"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_ex_perf_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Ex_perf.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response


# observation
@login_required
def read_observation_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_observation_admin').exists():
        observations = Observation.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_observation_battalion').exists():
        companies = request.user.battalion.companies.all()
        observations = Observation.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_observation_company').exists():
        company = request.user.company
        observations = Observation.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        observations = observations.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        observations = observations.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        observations = observations.filter(member__company=company_query)
    
    context = {
        "observations":observations,
        "name":"Observations"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_observation_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Observation.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response


# reward
@login_required
def read_reward_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_reward_admin').exists():
        rewards = Reward.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_reward_battalion').exists():
        companies = request.user.battalion.companies.all()
        rewards = Reward.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_reward_company').exists():
        company = request.user.company
        rewards = Reward.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        rewards = rewards.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        rewards = rewards.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        rewards = rewards.filter(member__company=company_query)
    
    context = {
        "rewards":rewards,
        "name":"Rewards"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_reward_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Reward.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response


# deserter
@login_required
def read_deserter_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_deserter_admin').exists():
        deserters = Deserter.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_deserter_battalion').exists():
        companies = request.user.battalion.companies.all()
        deserters = Deserter.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_deserter_company').exists():
        company = request.user.company
        deserters = Deserter.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    
    
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        deserters = deserters.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
        
    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        deserters = deserters.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        deserters = deserters.filter(member__company=company_query)
        
    year = request.GET.get('year', today.year)
    if year:
        deserters = deserters.filter(date__year=year)
    
    context = {
        "deserters":deserters,
        "name":"Deserters"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_deserter_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Deserter.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response

# AsltCourse
@login_required
def read_aslt_course_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_aslt_course_admin').exists():
        aslt_courses = AsltCourse.objects.all().order_by('-created_at', '-id')
        members = Member.objects.filter(active=True).order_by('id')
    elif role and role.modules.filter(name='read_aslt_course_battalion').exists():
        companies = request.user.battalion.companies.all()
        aslt_courses = AsltCourse.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    elif role and role.modules.filter(name='read_aslt_course_company').exists():
        company = request.user.company
        aslt_courses = AsltCourse.objects.filter(member__company=company).order_by('-created_at', '-id')
        members = Member.objects.filter(active=True, company=company).order_by('id')
    else:
        return render(request, 'others/no_permission.html')

    #get battalion
    battalion_query = request.GET.get('battalion_query', '')
    if battalion_query:
        aslt_courses = aslt_courses.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query', '')
    if company_query:
        aslt_courses = aslt_courses.filter(member__company=company_query)
    
    # Get result query
    result = request.GET.get("result", "")
    if result:
        aslt_courses = aslt_courses.filter(result=result)
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        aslt_courses = aslt_courses.filter(date__year=year)
        
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        aslt_courses = aslt_courses.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    
    context = {
        "aslt_courses":aslt_courses,
        "name":"Aslt Courses"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_aslt_course_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Alst_Course.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response



# FDFiring
@login_required
def read_fd_firing_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_fd_firing_admin').exists():
        fd_firings = FDFiring.objects.all().order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_fd_firing_battalion').exists():
        companies = request.user.battalion.companies.all()
        fd_firings = FDFiring.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_fd_firing_company').exists():
        company = request.user.company
        fd_firings = FDFiring.objects.filter(member__company=company).order_by('-created_at', '-id')
    else:
        return render(request, 'others/no_permission.html')

    
    #get battalion
    battalion_query = request.GET.get('battalion_query')
    if battalion_query:
        fd_firings = fd_firings.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query')
    if company_query:
        fd_firings = fd_firings.filter(member__company=company_query)
    
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        fd_firings = fd_firings.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    # Get result query
    result = request.GET.get("result", "")
    if result:
        fd_firings = fd_firings.filter(result=result)
        
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        fd_firings = fd_firings.filter(date_from__year=year)
    
    context = {
        "fd_firings":fd_firings,
        "name":"Fd Firings"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_fd_firing_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Fd_Firing.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response



# CourseShooting
@login_required
def read_course_shooting_pdf(request):
    role = request.user.role
    if role and role.modules.filter(name='read_course_shooting_admin').exists():
        course_shootings = CourseShooting.objects.all().order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_course_shooting_battalion').exists():
        companies = request.user.battalion.companies.all()
        course_shootings = CourseShooting.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
    elif role and role.modules.filter(name='read_course_shooting_company').exists():
        company = request.user.company
        course_shootings = CourseShooting.objects.filter(member__company=company).order_by('-created_at', '-id')
    else:
        return render(request, 'others/no_permission.html')

    
    #get battalion
    battalion_query = request.GET.get('battalion_query')
    if battalion_query:
        course_shootings = course_shootings.filter(member__company__battalion=battalion_query)
    #get company
    company_query = request.GET.get('company_query')
    if company_query:
        course_shootings = course_shootings.filter(member__company=company_query)
    
    # Get search query
    search_query = request.GET.get("search", "")  
    if search_query:
        # Use Q objects for OR logic
        course_shootings = course_shootings.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        )
    # Get result query
    result = request.GET.get("result", "")
    if result:
        course_shootings = course_shootings.filter(result=result)
        
    # Get year
    year = request.GET.get('year', today.year)
    if year:
        course_shootings = course_shootings.filter(date_from__year=year)

    context = {
        "course_shootings":course_shootings,
        "name":"Course Shootings"
    }
    # Load the HTML template and render it with context data
    template = get_template('performance/read_course_shooting_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="Course_Shooting.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response







#TODO: BDE/UNIT/SUB-UNIT MASTER REPORT 
def master_report_query(request):
    year = today.year
    role = request.user.role
    if role and role.modules.filter(name='master_report_admin').exists():
        battalions = Battalion.objects.all()
        return render(request, 'performance/master_report_query.html', {'battalions': battalions, 'year': year})
    elif role and role.modules.filter(name='master_report_battalion').exists():
        companies = request.user.battalion.companies.all()
        return render(request, 'performance/master_report_query.html', {'companies': companies, 'year': year})
    elif role and role.modules.filter(name='master_report_company').exists():
        company = request.user.company
        return render(request, 'performance/master_report_query.html', {'company': company, 'year': year})
    else:
        return render(request, 'others/no_permission.html')
    
def percent(part, total):
        return round((part / total) * 100, 2) if total > 0 else 0
    
    
# master report pdf
def master_report_pdf(request):
    company_name = None
    battalion_name = None
    company_id = request.POST.get('company', None) 
    battalion_id = request.POST.get('battalion',None)
    role = request.user.role
    # Check if the user has permission
    if role and role.modules.filter(name='master_report_admin').exists():
        pass
    elif role and role.modules.filter(name='master_report_battalion').exists():
        battalion_id = request.user.battalion.id
    elif role and role.modules.filter(name='master_report_company').exists():
        company_id = request.user.company.id
    else:
        return render(request, 'others/no_permission.html')
    today = get_custom_today()
    current_year = today.year
    year = request.POST.get('year', current_year)
    companies = Company.objects.all()
    # Posted
    posted = Member.objects.filter(active=True)
    # out of unit emp
    out_of_unit_emp = OutOfUnitEmp.objects.filter(status=True, member__active=True, member__t_company__isnull=True)
    # held : posted - out of unit emp
    held = posted.exclude(id__in=out_of_unit_emp.values_list('member_id', flat=True))
    
    
    # Ops Depl
    ops_depl = Member.objects.filter(ops_depl=True, active=True)
    
    #p_leave
    p_leave = Leave.objects.filter(leave_type__name='p_leave', date__year=year, member__in=held).values('member').distinct()
    #med_cat
    srv_info = ServiceInformation.objects.filter(member__in=held).values('member').distinct()
    #cmh
    cmh = OtherReason.objects.filter(leave_type__name='cmh', start_date__year=year,status=True, member__in=held).values('member').distinct()
    #unauth_absent
    awol = Leave.objects.filter(leave_type__name='awol', date__year=year).values('member').distinct()
    osl = Leave.objects.filter(leave_type__name='osl', date__year=year).values('member').distinct()
    #deserter
    deserter = Deserter.objects.filter(date__year=year).values('member').distinct()

    #punishment
    punishments = Punishment.objects.filter(date__year=year).order_by('-date', '-id')
    #observation
    observations = Observation.objects.all().order_by('-date', '-id')
    #pet
    pets_1st = PET.objects.filter(by_annual=1, date__year=year, member__in=held).order_by('-date','-id')
    pets_2nd = PET.objects.filter(by_annual=2, date__year=year, member__in=held).order_by('-date','-id')
    #ret
    rets = RET.objects.filter(ret=1, date__year=year,member__in=held).order_by('-date','-id')
    #gr_firing
    gr_firings = GRFiring.objects.filter(date__year=year, member__in=held).order_by('-date','-id')
    #sm
    sms = SM.objects.filter(date__year=year, member__in=held).order_by('-date','-id')

    
    if battalion_id:
        battalion_name = Battalion.objects.get(id=battalion_id).name
        companies = companies.filter(battalion=battalion_id)
        # Total Posted
        posted = posted.filter(Q(company__in=companies)|Q(p_company__in=companies), active=True)
        # Total Out of Unit
        out_of_unit_emp = OutOfUnitEmp.objects.filter(Q(member__company__in=companies)|Q(member__p_company__in=companies), status=True, member__active=True).exclude(member__t_company__in=companies)
        # held
        held = posted.exclude(id__in=out_of_unit_emp.values_list('member_id', flat=True))
        # Ops Depl
        ops_depl = ops_depl.filter(company__in=companies)
        #p_leave
        p_leave = p_leave.filter(member__in=held)
        #med_cat
        srv_info = srv_info.filter(member__in=held)
        #cmh
        cmh = cmh.filter(member__in=held)
        #unauth_absent
        awol = awol.filter(member__company__in=companies)
        osl = osl.filter(member__company__in=companies)
        #deserter
        deserter = deserter.filter(member__company__in=companies)
        
        #punishment
        punishments = punishments.filter(member__company__in=companies)
        #observation
        observations = observations.filter(member__company__in=companies)
        #pet
        pets_1st = pets_1st.filter(member__in=held)
        pets_2nd = pets_2nd.filter(member__in=held)
        #ret
        rets = rets.filter(member__in=held)
        #gr_firing
        gr_firings = gr_firings.filter(member__in=held)
        #sm
        sms = sms.filter(member__in=held)
        
        
    if company_id:
        companies = companies.filter(id=company_id)
        company = Company.objects.get(id=company_id)
        company_name = company.name
        battalion_name = company.battalion.name
        #total posted
        posted = posted.filter(Q(company=company)|Q(p_company=company), active=True)
        #total out of unit
        out_of_unit_emp = OutOfUnitEmp.objects.filter(Q(member__company=company)|Q(member__p_company=company), status=True, member__active=True).exclude(member__t_company=company)
        #held
        held = posted.exclude(id__in=out_of_unit_emp.values_list('member_id', flat=True))
        # Ops Depl
        ops_depl = ops_depl.filter(company=company)

        #p_leave
        p_leave = p_leave.filter(member__in=held)
        #med_cat
        srv_info = srv_info.filter(member__in=held)
        #cmh
        cmh = cmh.filter(member__in=held)
        #unauth_absent
        awol = awol.filter(member__company=company)
        osl = osl.filter(member__company=company)
        #deserter
        deserter = deserter.filter(member__company=company)
        
        #punishments
        punishments = punishments.filter(member__company=company)
        #observation
        observations = observations.filter(member__company=company)
        #pet
        pets_1st = pets_1st.filter(member__in=held)
        pets_2nd = pets_2nd.filter(member__in=held)
        #ret
        rets = rets.filter(member__in=held)
        #gr_firing
        gr_firings = gr_firings.filter(member__in=held)
        #sm
        sms = sms.filter(member__in=held)



    
    
    # Aggregate auth
    toe_auth = companies.aggregate(**{field: Sum(field) for field in member_types_fields})
    toe_auth['total'] = sum(value or 0 for value in toe_auth.values())
    ere_auth = companies.aggregate(**{field: Sum(field) for field in ere_member_types_fields})
    ere_auth['total'] = sum(value or 0 for value in ere_auth.values())
    total_auth = toe_auth['total'] + ere_auth['total']
    
    # Posted
    total_posted = posted.count()
    # held
    total_held = held.count()
    #Out of unit emp
    total_out_of_unit_emp = out_of_unit_emp.count()
    
    # Ops Depl
    total_ops_depl = ops_depl.count()
    offr_ops_depl = ops_depl.filter(rank__member_status__id=1).count()
    jco_ops_depl = ops_depl.filter(rank__member_status__id=2).count()
    or_ops_depl = ops_depl.filter(rank__member_status__id=3).count()
    civ_ops_depl = ops_depl.filter(rank__member_status__id=4).count()
    
    #held
    total_offr_held = held.filter(rank__member_status__id=1).count()
    total_jco_held = held.filter(rank__member_status__id=2).count()
    total_or_held = held.filter(rank__member_status__id=3).count()
    total_civ_held = held.filter(rank__member_status__id=4).count()
    
    #completed p_leave
    #offr p_leave
    completed_offr_p_leave = p_leave.filter(member__rank__member_status__id=1).count()
    #jco p_leave
    completed_jco_p_leave = p_leave.filter(member__rank__member_status__id=2).count()
    #or p_leave
    completed_or_p_leave = p_leave.filter(member__rank__member_status__id=3).count()
    #civ p_leave
    completed_civ_p_leave = p_leave.filter(member__rank__member_status__id=4).count()
    
    #leftover p_leave
    #offr p_leave
    leftover_offr_p_leave = total_offr_held - completed_offr_p_leave
    #jco p_leave
    leftover_jco_p_leave = total_jco_held - completed_jco_p_leave
    #or p_leave
    leftover_or_p_leave = total_or_held - completed_or_p_leave
    #civ p_leave
    leftover_civ_p_leave = total_civ_held - completed_civ_p_leave

    
    
    #med_cat
    med_cat_b = srv_info.filter(med_cat="b")
    med_cat_c = srv_info.filter(med_cat="c")
    
    cmh_offr = cmh.filter(member__rank__member_status=1).count()
    med_cat_b_offr = med_cat_b.filter(member__rank__member_status=1).count()
    med_cat_c_offr = med_cat_c.filter(member__rank__member_status=1).count()
    
    cmh_jco = cmh.filter(member__rank__member_status=2).count()
    med_cat_b_jco = med_cat_b.filter(member__rank__member_status=2).count()
    med_cat_c_jco = med_cat_c.filter(member__rank__member_status=2).count()
    
    cmh_or = cmh.filter(member__rank__member_status=3).count()
    med_cat_b_or = med_cat_b.filter(member__rank__member_status=3).count()
    med_cat_c_or = med_cat_c.filter(member__rank__member_status=3).count()
    
    cmh_civ = cmh.filter(member__rank__member_status=4).count()
    med_cat_b_civ = med_cat_b.filter(member__rank__member_status=4).count()
    med_cat_c_civ = med_cat_c.filter(member__rank__member_status=4).count()
    
    #unauth_absent
    awol_offr = awol.filter(member__rank__member_status=1).count()
    awol_jco = awol.filter(member__rank__member_status=2).count()
    awol_or = awol.filter(member__rank__member_status=3).count()
    awol_civ = awol.filter(member__rank__member_status=4).count()
    
    osl_offr = osl.filter(member__rank__member_status=1).count()
    osl_jco = osl.filter(member__rank__member_status=2).count()
    osl_or = osl.filter(member__rank__member_status=3).count()
    osl_civ = osl.filter(member__rank__member_status=4).count()
    
    #deserter
    deserter_offr = deserter.filter(member__rank__member_status=1).count()
    deserter_jco = deserter.filter(member__rank__member_status=2).count()
    deserter_or = deserter.filter(member__rank__member_status=3).count()
    deserter_civ = deserter.filter(member__rank__member_status=4).count()
    
    # punishment
    total_punishment = punishments.values('member').distinct().count()
    #pet_1st
    pet_1st_pass = pets_1st.filter(result=1).values('member_id').distinct()
    pet_1st_exempted = pets_1st.filter(result=0).exclude(member_id__in=pet_1st_pass.values('member_id')).values('member_id').distinct()
    pet_1st_fail = pets_1st.filter(result=2).exclude(member_id__in=pet_1st_pass.values('member_id')).exclude(member_id__in=pet_1st_exempted.values('member_id')).values('member_id').distinct()
    pet_1st_not_appeared = held.exclude(id__in=pets_1st.values_list('member_id', flat=True))
    
    total_pet_1st_pass = pet_1st_pass.count()
    total_pet_1st_fail = pet_1st_fail.count()
    total_pet_1st_exempted = pet_1st_exempted.count()
    total_pet_1st_not_appeared = pet_1st_not_appeared.count()

    percent_pet_1st_pass = percent(total_pet_1st_pass, total_held)
    percent_pet_1st_fail = percent(total_pet_1st_fail, total_held)
    percent_pet_1st_exempted = percent(total_pet_1st_exempted, total_held)
    percent_pet_1st_not_appeared = percent(total_pet_1st_not_appeared, total_held)
    
    
    #pet_2nd
    pet_2nd_pass = pets_2nd.filter(result=1).values('member_id').distinct()
    pet_2nd_exempted = pets_2nd.filter(result=0).exclude(member_id__in=pet_2nd_pass.values('member_id')).values('member_id').distinct()
    pet_2nd_fail = pets_2nd.filter(result=2).exclude(member_id__in=pet_2nd_pass.values('member_id')).exclude(member_id__in=pet_2nd_exempted.values('member_id')).values('member_id').distinct()
    pet_2nd_not_appeared = held.exclude(id__in=pets_2nd.values_list('member_id', flat=True))
    
    total_pet_2nd_pass = pet_2nd_pass.count()
    total_pet_2nd_fail = pet_2nd_fail.count()
    total_pet_2nd_exempted = pet_2nd_exempted.count()
    total_pet_2nd_not_appeared = pet_2nd_not_appeared.count()

    percent_pet_2nd_pass = percent(total_pet_2nd_pass, total_held)
    percent_pet_2nd_fail = percent(total_pet_2nd_fail, total_held)
    percent_pet_2nd_exempted = percent(total_pet_2nd_exempted, total_held)
    percent_pet_2nd_not_appeared = percent(total_pet_2nd_not_appeared, total_held)
    
    
    #ret
    ret_pass = rets.filter(result=1).values('member_id').distinct()
    ret_exempted = rets.filter(result=0).exclude(member_id__in=ret_pass.values('member_id')).values('member_id').distinct()
    ret_fail = rets.filter(result=2).exclude(member_id__in=ret_pass.values('member_id')).exclude(member_id__in=ret_exempted.values('member_id')).values('member_id').distinct()
    ret_not_appeared = held.exclude(id__in=rets.values_list('member_id', flat=True))
    
    total_ret_pass = ret_pass.count()
    total_ret_fail = ret_fail.count()
    total_ret_exempted = ret_exempted.count()
    total_ret_not_appeared = ret_not_appeared.count()
 
    percent_ret_pass = percent(total_ret_pass, total_held)
    percent_ret_fail = percent(total_ret_fail, total_held)
    percent_ret_exempted = percent(total_ret_exempted, total_held)
    percent_ret_not_appeared = percent(total_ret_not_appeared, total_held)
    
    
    
    #gr_firing
    gr_firing_pass = gr_firings.filter(result=1).values('member_id').distinct()
    gr_firing_exempted = gr_firings.filter(result=0).exclude(member_id__in=gr_firing_pass.values('member_id')).values('member_id').distinct()
    gr_firing_fail = gr_firings.filter(result=2).exclude(member_id__in=gr_firing_pass.values('member_id')).exclude(member_id__in=gr_firing_exempted.values('member_id')).values('member_id').distinct()
    gr_firing_not_appeared = held.exclude(id__in=gr_firings.values_list('member_id', flat=True))
    
    total_gr_firing_pass = gr_firing_pass.count()
    total_gr_firing_fail = gr_firing_fail.count()
    total_gr_firing_exempted = gr_firing_exempted.count()
    total_gr_firing_not_appeared = gr_firing_not_appeared.count()

    percent_gr_firing_pass = percent(total_gr_firing_pass, total_held)
    percent_gr_firing_fail = percent(total_gr_firing_fail, total_held)
    percent_gr_firing_exempted = percent(total_gr_firing_exempted, total_held)
    percent_gr_firing_not_appeared = percent(total_gr_firing_not_appeared, total_held)
    
    
    #sm
    sm_1st = sms.filter(attempt=1).values('member_id').distinct()
    sm_2nd = sms.filter(attempt=2).values('member_id').distinct()
    sm_3rd = sms.filter(attempt=3).values('member_id').distinct()
    sm_4th = sms.filter(attempt=4).values('member_id').distinct()
    
    total_sm_1st = sm_1st.count()
    total_sm_2nd = sm_2nd.count()
    total_sm_3rd = sm_3rd.count()
    total_sm_4th = sm_4th.count()
    
    percent_sm_1st = percent(total_sm_1st, total_held)
    percent_sm_2nd = percent(total_sm_2nd, total_held)
    percent_sm_3rd = percent(total_sm_3rd, total_held)
    percent_sm_4th = percent(total_sm_4th, total_held)
    
    sm_not_appeared = held.exclude(id__in=sms.values_list('member_id', flat=True))
    
    total_sm_not_appeared = sm_not_appeared.count()
    percent_sm_not_appeared = percent(total_sm_not_appeared, total_held)
    

    
    context = {
        "year": year,
        "date":today,
        "company_name": company_name,
        "battalion_name": battalion_name,
        "toe_auth": toe_auth,
        "ere_auth": ere_auth,
        "total_auth": total_auth,
        "total_posted": total_posted,
        'deficiency': total_auth - total_posted,
        "total_out_of_unit_emp": total_out_of_unit_emp,
        'held': total_held,
        "total_ops_depl": total_ops_depl,
        "offr_ops_depl": offr_ops_depl,
        "jco_ops_depl": jco_ops_depl,
        "or_ops_depl": or_ops_depl,
        "civ_ops_depl": civ_ops_depl,
        
        #hel
        "total_held": total_held,
        "total_offr_held": total_offr_held,
        "total_jco_held": total_jco_held,
        "total_or_held": total_or_held,
        "total_civ_held": total_civ_held,
        #p_leave
        "completed_offr_p_leave": completed_offr_p_leave,
        "completed_jco_p_leave": completed_jco_p_leave,
        "completed_or_p_leave": completed_or_p_leave,
        "completed_civ_p_leave": completed_civ_p_leave,
        "leftover_offr_p_leave": leftover_offr_p_leave,
        "leftover_jco_p_leave": leftover_jco_p_leave,
        "leftover_or_p_leave": leftover_or_p_leave,
        "leftover_civ_p_leave": leftover_civ_p_leave,

    
        #med_cat
        "cmh_offr": cmh_offr,
        "med_cat_b_offr": med_cat_b_offr,
        "med_cat_c_offr": med_cat_c_offr,
        "cmh_jco": cmh_jco,
        "med_cat_b_jco": med_cat_b_jco,
        "med_cat_c_jco": med_cat_c_jco,
        "cmh_or": cmh_or,
        "med_cat_b_or": med_cat_b_or,
        "med_cat_c_or": med_cat_c_or,
        "cmh_civ": cmh_civ,
        "med_cat_b_civ": med_cat_b_civ,
        "med_cat_c_civ": med_cat_c_civ,
        #unauth_absent
        "awol_offr": awol_offr,
        "awol_jco": awol_jco,
        "awol_or": awol_or,
        "awol_civ": awol_civ,
        "osl_offr": osl_offr,
        "osl_jco": osl_jco,
        "osl_or": osl_or,
        "osl_civ": osl_civ,
        #deserter
        "deserter_offr": deserter_offr,
        "deserter_jco": deserter_jco,
        "deserter_or": deserter_or,
        "deserter_civ": deserter_civ,
        #punishment
        "punishments":punishments,
        "total_punishment":total_punishment,
        #observation
        "observations":observations,
        #pet_1st
        "pet_1st_not_appeared":pet_1st_not_appeared,
        "total_pet_1st_pass":total_pet_1st_pass,
        "total_pet_1st_fail":total_pet_1st_fail,
        "total_pet_1st_exempted":total_pet_1st_exempted,
        "total_pet_1st_not_appeared":total_pet_1st_not_appeared,
        "percent_pet_1st_pass":percent_pet_1st_pass,
        "percent_pet_1st_fail":percent_pet_1st_fail,
        "percent_pet_1st_exempted":percent_pet_1st_exempted,
        "percent_pet_1st_not_appeared":percent_pet_1st_not_appeared,
        #pet_2nd
        "pet_2nd_not_appeared":pet_2nd_not_appeared,
        "total_pet_2nd_pass":total_pet_2nd_pass,
        "total_pet_2nd_fail":total_pet_2nd_fail,
        "total_pet_2nd_exempted":total_pet_2nd_exempted,
        "total_pet_2nd_not_appeared":total_pet_2nd_not_appeared,
        "percent_pet_2nd_pass":percent_pet_2nd_pass,
        "percent_pet_2nd_fail":percent_pet_2nd_fail,
        "percent_pet_2nd_exempted":percent_pet_2nd_exempted,
        "percent_pet_2nd_not_appeared":percent_pet_2nd_not_appeared,
        #ret
        "ret_not_appeared":ret_not_appeared,
        "total_ret_pass":total_ret_pass,
        "total_ret_fail":total_ret_fail,
        "total_ret_exempted":total_ret_exempted,
        "total_ret_not_appeared":total_ret_not_appeared,
        "percent_ret_pass":percent_ret_pass,
        "percent_ret_fail":percent_ret_fail,
        "percent_ret_exempted":percent_ret_exempted,
        "percent_ret_not_appeared":percent_ret_not_appeared,
        #gr_firing
        "gr_firing_not_appeared":gr_firing_not_appeared,
        "total_gr_firing_pass":total_gr_firing_pass,
        "total_gr_firing_fail":total_gr_firing_fail,
        "total_gr_firing_exempted":total_gr_firing_exempted,
        "total_gr_firing_not_appeared":total_gr_firing_not_appeared,
        "percent_gr_firing_pass":percent_gr_firing_pass,
        "percent_gr_firing_fail":percent_gr_firing_fail,
        "percent_gr_firing_exempted":percent_gr_firing_exempted,
        "percent_gr_firing_not_appeared":percent_gr_firing_not_appeared,
        #sm
        "sm_not_appeared":sm_not_appeared,
        "total_sm_1st":total_sm_1st,
        "total_sm_2nd":total_sm_2nd,
        "total_sm_3rd":total_sm_3rd,
        "total_sm_4th":total_sm_4th,
        "percent_sm_1st":percent_sm_1st,
        "percent_sm_2nd":percent_sm_2nd,
        "percent_sm_3rd":percent_sm_3rd,
        "percent_sm_4th":percent_sm_4th,
        "total_sm_not_appeared":total_sm_not_appeared,
        "percent_sm_not_appeared":percent_sm_not_appeared,

    }
    
    # Load the HTML template and render it with context data
    template = get_template('performance/master_report_pdf.html')
    html = template.render(context)

    # Create a response with PDF content type
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = f'inline; filename="master_report.pdf"'

    # Convert HTML to PDF
    pisa_status = pisa.CreatePDF(html, dest=response)

    if pisa_status.err:
        return HttpResponse("Error generating PDF", status=500)
    
    return response