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

#for pdf
from django.template.loader import get_template
from django.http import HttpResponse
from xhtml2pdf import pisa



#TODO: battalion dashboard   
@role_required('dashboard_battalion') 
def dashboard_battalion(request):
    date = get_custom_today()
    battalion = request.user.battalion
    companies = Company.objects.filter(battalion=battalion)
    role = request.user.role
    attendance_summary = AttendanceSummary.objects.filter(attendance_summary_cart__battalion=battalion, date=date)
    
    if role and role.modules.filter(name='adjutant_battalion').exists():
        attendance_summary = attendance_summary.filter(attendance_summary_cart__battalion_approved=True)
  
    total_posted = Member.objects.filter(Q(company__in=companies)|Q(p_company__in=companies), active=True).count()
    # Dynamically create the aggregate query
    aggregate_query = {field: Sum(field) for field in field_names}

    # Execute the aggregate query
    record = attendance_summary.aggregate(**aggregate_query)
    # Replace None values with 0
    record = {key: value or 0 for key, value in record.items()}
    # calculate out of unit emp
    total_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).count()
    total_ops_depl = Member.objects.filter(company__in=companies, ops_depl=True, active=True).count()

    # Aggregate values
    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']
    

    # Calculate combined totals
    combined_total_auth = {}
    for field in member_types_fields:
        toe_value = toe_auth.get(field) or 0
        ere_value = ere_auth.get(f'ere_{field}') or 0
        combined_total_auth[field + '_total'] = toe_value + ere_value

    # Optional: calculate overall total of all combined
    combined_total_auth['grand_total'] = sum(combined_total_auth.values())

    # Create a dictionary to store counts dynamically
    posted = {
    field: Member.objects.filter(Q(company__in=companies)|Q(p_company__in=companies),member_type__name=field,active=True).count() for field in member_types_fields
    }
    # Calculate total sum of all members
    posted['total'] = sum(posted.values())
    
    # Create a dictionary to store counts dynamically
    ops_depl = {
    field: Member.objects.filter(member_type__name=field,active=True,ops_depl=True,company__in=companies).count() for field in member_types_fields
    }
    # Calculate total sum of all members
    ops_depl['total'] = sum(ops_depl.values())
    
    # Create a dictionary to store counts dynamically
    out_of_unit_emp = {
    field: OutOfUnitEmp.objects.filter(Q(member__company__in=companies)|Q(member__p_company__in=companies), status=True, type_name=field, member__active=True).exclude(member__t_company__in=companies).count() for field in leave_out_of_unit_emp_fields
    }
    # Calculate total sum of all members
    out_of_unit_emp['total'] = sum(out_of_unit_emp.values())
    

    total_leaves =attendance_summary.aggregate(**{field: Sum(field) for field in total_leaves_fields})
    total_cct =attendance_summary.aggregate(**{field: Sum(field) for field in cct_fields})
    total_unauth_absent =attendance_summary.aggregate(**{field: Sum(field) for field in unauth_absent_fields})
    total_other_reason =attendance_summary.aggregate(**{field: Sum(field) for field in other_reason_fields})

    # Calculate the total sum and append it to total_leaves
    total_leaves['total'] = sum(value or 0 for value in total_leaves.values())
    total_cct['total'] = sum(value or 0 for value in total_cct.values())
    total_unauth_absent['total'] = sum(value or 0 for value in total_unauth_absent.values())
    total_other_reason['total'] = sum(value or 0 for value in total_other_reason.values())
    context = {
        'total_posted':total_posted,
        'total_auth':total_auth,
        'toe_auth':toe_auth,
        'ere_auth':ere_auth,
        'total_leaves':total_leaves,
        'total_cct':total_cct,
        'total_out_of_unit_emp':total_out_of_unit_emp,
        'total_ops_depl':total_ops_depl,
        'total_unauth_absent':total_unauth_absent,
        'total_other_reason':total_other_reason,
        'deficiency': total_auth - total_posted,
        'held': total_posted - total_out_of_unit_emp,
        'record': record,
        'combined_total_auth': combined_total_auth,
        'posted': posted,
        'ops_depl':ops_depl,
        'out_of_unit_emp': out_of_unit_emp,
    }
    return render(request,"dashboard/dashboard_battalion.html",context)


@role_required('dashboard_battalion')
def parade_state_battalion(request,date=None):
    if date:
        date = datetime.strptime(date, "%Y-%m-%d").date()
    else:
        date = get_custom_today()
    battalion = request.user.battalion
    
    role = request.user.role
    attendance_summary = AttendanceSummary.objects.filter(attendance_summary_cart__battalion=battalion, date=date)
    
    if role and role.modules.filter(name='adjutant_battalion').exists():
        attendance_summary = attendance_summary.filter(attendance_summary_cart__battalion_approved=True)

    # Get first matched AttendanceSummary (if any)
    summary = attendance_summary.select_related('attendance_summary_cart').first()

    # Decide cart_id
    cart_id_daily = None
    if summary and not summary.attendance_summary_cart.battalion_approved:
        cart_id_daily = summary.attendance_summary_cart.id
   
    # Decide cart_id
    cart_id_adjutant = None
    if summary and not summary.attendance_summary_cart.adjutant_approved:
        cart_id_adjutant = summary.attendance_summary_cart.id
  
  
  
    #fetch attendance related all company
    company = []
    if cart_id_daily != None:
       for i in attendance_summary:
           company.append(i.company)
           
    # Dynamically create the aggregate query
    aggregate_query = {field: Sum(field) for field in field_names}

    # Execute the aggregate query
    totals = attendance_summary.aggregate(**aggregate_query)

    # Replace None values with 0
    totals = {key: value or 0 for key, value in totals.items()}    
    
    context = {
        'records': attendance_summary,
        'totals': totals,
        'date': date,
        'cart_id_daily':cart_id_daily,
        'cart_id_adjutant':cart_id_adjutant,
        'company':company,
        'battalion_name': battalion.name,
    }
    
    return render(request,'battalion/attendance_table.html',context)

@role_required('daily_battalion')
def parade_state_submit_battalion(request,id):
    attendance_summary_cart = AttendanceSummaryCart.objects.get(id=id)
    attendance_summary_cart.battalion_approved = True
    attendance_summary_cart.save()
    messages.success(request, "Attendance submitted successfully")
    return redirect('parade_state_battalion')
    
    
@role_required('daily_battalion')
def parade_state_reject_battalion(request):
    company_id = request.POST.get('company_id')
    date = get_custom_today()
    attendance_summary = AttendanceSummary.objects.filter(company__id=company_id,date=date).first()
    company_take_attendance = CompanyTakeAttendance.objects.filter(attendance_date=date,company__id=company_id).first()
    if not company_id:
        messages.error(request, "Company ID not found")
        return redirect('parade_state_battalion')
    if attendance_summary and company_take_attendance:
        attendance_summary.delete()
        company_take_attendance.delete()
        messages.success(request, "Attendance rejected successfully")
        return redirect('parade_state_battalion')
    else:
        messages.error(request, "Attendance not found")
        return redirect('parade_state_battalion')
    
    
@role_required('adjutant_battalion')
def parade_state_submit_adjutant_battalion(request,id):
    attendance_summary_cart = AttendanceSummaryCart.objects.get(id=id)
    attendance_summary_cart.adjutant_approved = True
    attendance_summary_cart.save()
    messages.success(request, "Attendance submitted successfully")
    return redirect('parade_state_battalion')
    
    
@role_required('adjutant_battalion')
def parade_state_reject_adjutant_battalion(request,id):
    attendance_summary_cart = AttendanceSummaryCart.objects.get(id=id)
    attendance_summary_cart.battalion_approved = False
    attendance_summary_cart.save()
    messages.success(request, "Attendance rejected successfully")
    return redirect('parade_state_battalion')




#list attendance summary
@role_required('dashboard_battalion')
def parade_state_list_battalion(request): 
    date = request.GET.get('date')  # Get selected date from request
    battalion= request.user.battalion
    role = request.user.role
    dates = AttendanceSummaryCart.objects.filter(
            battalion=battalion,
            battalion_approved=True  # Filters where battalion is in the list of battalion
        )
    if role and role.modules.filter(name='adjutant_battalion').exists():
        dates = dates.filter(adjutant_approved=True)
        
    if date:
        dates = dates.filter(date=date)
        
    dates = dates.values_list("date", flat=True).distinct().order_by('-date')

    # paginator for dates
    paginator = Paginator(dates, 30)
    page_number = request.GET.get('page')
    dates = paginator.get_page(page_number)
    context = {
        "dates": dates,  # Pass the dates to the template
        "date": date
    }
    return render(request, 'battalion/list_attendance_summary.html', context)





@role_required('other_battalion')
def parade_state_jco_battalion(request, date):
    battalion= request.user.battalion
    attendance_summary = AttendanceSummary.objects.filter(attendance_summary_cart__battalion=battalion,date=date)

    # Dynamically create the aggregate query
    aggregate_query = {field: Sum(field) for field in jco_fields}

    # Execute the aggregate query
    totals = attendance_summary.aggregate(**aggregate_query)

    # Replace None values with 0
    totals = {key: value or 0 for key, value in totals.items()}    
    
    context = {
        'records': attendance_summary,
        'totals': totals,
        'date': datetime.strptime(date, "%Y-%m-%d").date(),
        'battalion_name': battalion.name,
    }
    
    return render(request,'battalion/parade_state_jco.html',context)

@role_required('other_battalion')
def parade_state_offr_battalion(request, date):
    battalion= request.user.battalion
    attendance_summary = AttendanceSummary.objects.filter(attendance_summary_cart__battalion=battalion,date=date)
    attendance_summary = AttendanceSummaryOffr.objects.filter(attendance_summary__in=attendance_summary)
  
    # Dynamically create the aggregate query
    aggregate_query = {field: Sum(field) for field in offr_fields}

    # Execute the aggregate query
    totals = attendance_summary.aggregate(**aggregate_query)

    # Replace None values with 0
    totals = {key: value or 0 for key, value in totals.items()}    
    
    context = {
        'records': attendance_summary,
        'totals': totals,
        'date': datetime.strptime(date, "%Y-%m-%d").date(),
        'battalion_name': battalion.name,
    }
    
    return render(request,'battalion/parade_state_offr.html',context)

@role_required('other_battalion')
def parade_state_company_battalion(request, date, company_id):
    company = Company.objects.get(id=company_id)
    attendance_summary = AttendanceSummary.objects.filter(date=date,company=company).first()
    
    context = {
        'record': attendance_summary,
        'date': date,
    }
    
    return render(request,'battalion/view_company_attendance_summary.html',context)


#TODO: PDF




@role_required('other_battalion')
def parade_state_pdf_battalion(request, date):
    battalion= request.user.battalion
    attendance_summary = AttendanceSummary.objects.filter(attendance_summary_cart__battalion=battalion,date=date)
  
    # Dynamically create the aggregate query
    aggregate_query = {field: Sum(field) for field in field_names}

    # Execute the aggregate query
    totals = attendance_summary.aggregate(**aggregate_query)

    # Replace None values with 0
    totals = {key: value or 0 for key, value in totals.items()}    
    
    context = {
        'records': attendance_summary,
        'totals': totals,
        'date': datetime.strptime(date, "%Y-%m-%d").strftime('%d-%b-%Y'),
        'battalion_name': battalion.name,
    }
    # Load the HTML template and render it with context data
    template = get_template('battalion/attendance_summary_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="manpower_parade_state_of_{battalion.name}_{date}.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

@role_required('other_battalion')
def parade_state_jco_pdf_battalion(request, date):
    battalion= request.user.battalion
    attendance_summary = AttendanceSummary.objects.filter(attendance_summary_cart__battalion=battalion,date=date)
    # Dynamically create the aggregate query
    aggregate_query = {field: Sum(field) for field in jco_fields}

    # Execute the aggregate query
    totals = attendance_summary.aggregate(**aggregate_query)

    # Replace None values with 0
    totals = {key: value or 0 for key, value in totals.items()}    
    
    context = {
        'records': attendance_summary,
        'totals': totals,
        'date': datetime.strptime(date, "%Y-%m-%d").strftime('%d-%b-%Y'),
        'battalion_name': battalion.name,
    }
    # Load the HTML template and render it with context data
    template = get_template('battalion/parade_state_jco_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="jco_manpower_parade_state_of_{battalion.name}_{date}.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

@role_required('other_battalion')
def parade_state_offr_pdf_battalion(request, date):
    battalion= request.user.battalion
    attendance_summary = AttendanceSummary.objects.filter(attendance_summary_cart__battalion=battalion,date=date)
    attendance_summary = AttendanceSummaryOffr.objects.filter(attendance_summary__in=attendance_summary)
  
    # Dynamically create the aggregate query
    aggregate_query = {field: Sum(field) for field in offr_fields}

    # Execute the aggregate query
    totals = attendance_summary.aggregate(**aggregate_query)

    # Replace None values with 0
    totals = {key: value or 0 for key, value in totals.items()}    
    
    context = {
        'records': attendance_summary,
        'totals': totals,
        'date': datetime.strptime(date, "%Y-%m-%d").strftime('%d-%b-%Y'),
        'battalion_name': battalion.name,
    }
    # Load the HTML template and render it with context data
    template = get_template('battalion/parade_state_offr_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="offr manpower_parade_state_of_{battalion.name}_{date}.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: Attendance member
@role_required('dashboard_battalion')  
def attendance_member_list_battalion(request, date, company_id):
    try:
        # Convert string to date object
        date = datetime.strptime(date, "%Y-%m-%d").date()
    except ValueError:
        messages.error(request, "Invalid date format. Please use YYYY-MM-DD.")
        return redirect('attendance_member_list_battalion')

    # Get attendance records
    attendance_records = AttendanceMember.objects.filter(
        member__company__id=company_id,
        attendance__attendance_date=date
    ).select_related('attendance', 'member')

    # Get leave details for absent members
    leave_records = Leave.objects.filter(
        member__company__id=company_id,
        date=date  # Assuming 'created_at' stores leave request date
    ).select_related('member', 'leave_type')
    search_query = request.GET.get("search", "")  # Get search query
    if search_query:
        # Use Q objects for OR logic
        attendance_records = attendance_records.filter(
            Q(member__army_no__icontains=search_query) |
            Q(member__mobile_no__icontains=search_query) |
            Q(member__name__icontains=search_query)
        ) 
    context = {
        'attendance_records': attendance_records,
        'leave_records': leave_records,
        'date': date,
        'company': Company.objects.get(id=company_id),
        'search_query': search_query
    }

    return render(request, 'dashboard/attendance_report.html', context)


@role_required('dashboard_battalion')
def absent_list_battalion(request,member_type):
    date = get_custom_today()
    battalion = request.user.battalion
    companies = Company.objects.filter(battalion=battalion)
    # Get attendance records
    attendance_records = AttendanceMember.objects.filter(
        member__company__in = companies,
        attendance__attendance_date=date,
        status=False
    ).select_related('attendance', 'member')

    # Get leave details for total members
    leave_records = Leave.objects.filter(
        member__company__in = companies,
        date=date 
    ).select_related('member', 'leave_type')
    
    if member_type != 'total':
        attendance_records = attendance_records.filter(member__member_type__name=member_type)
        leave_records = leave_records.filter(member__member_type__name=member_type)

    context = {
        'attendance_records': attendance_records,
        'leave_records': leave_records,
        'date': date,
    }

    return render(request, 'dashboard/attendance_report.html', context)


@role_required('dashboard_battalion')
def present_list_battalion(request,member_type):
    date = get_custom_today()
    battalion = request.user.battalion
    companies = Company.objects.filter(battalion=battalion)
    # Get attendance records
    attendance_records = AttendanceMember.objects.filter(
        member__company__in = companies,
        attendance__attendance_date=date,
        status=True
    ).select_related('attendance', 'member')

    # Get leave details for total members
    leave_records = Leave.objects.filter(
        member__company__in = companies,
        date=date 
    ).select_related('member', 'leave_type')
    
    if member_type != 'total':
        attendance_records = attendance_records.filter(member__member_type__name=member_type)
        leave_records = leave_records.filter(member__member_type__name=member_type)

    context = {
        'attendance_records': attendance_records,
        'leave_records': leave_records,
        'date': date,
    }

    return render(request, 'dashboard/attendance_report.html', context)

@role_required('dashboard_battalion')
def leave_list_battalion(request,type="total"):
    date = get_custom_today()
    battalion = request.user.battalion
    companies = Company.objects.filter(battalion=battalion)
    # Get attendance records
    attendance_records = AttendanceMember.objects.filter(
        member__company__in = companies,
        attendance__attendance_date=date,
        status=False
    ).select_related('attendance', 'member')

    # Get leave details for present members
    leave_records = Leave.objects.filter(
        date=date 
    ).select_related('member', 'leave_type')
    
    if type == 'total_leaves':
    #get leave attendance records
        leave_attendance_records = []
        for i in attendance_records:
            for j in leave_records:
                if i.member == j.member and j.leave_type is not None and j.leave_type.name in leave_main_leaves:
                    leave_attendance_records.append(i)
    elif type == 'total_cct':
        #get leave attendance records
        leave_attendance_records = []
        for i in attendance_records:
            for j in leave_records:
                if i.member == j.member and j.leave_type is not None and j.leave_type.name in leave_cct_fields:
                    leave_attendance_records.append(i)
    elif type == 'total_unauth_absent':
        #get leave attendance records
        leave_attendance_records = []
        for i in attendance_records:
            for j in leave_records:
                if i.member == j.member and j.leave_type is not None and j.leave_type.name in leave_unauth_absent_fields:
                    leave_attendance_records.append(i)
    elif type == 'total_other_reason':
        #get leave attendance records
        leave_attendance_records = []
        for i in attendance_records:
            for j in leave_records:
                if i.member == j.member and j.leave_type is not None and j.leave_type.name in leave_other_reason_fields:
                    leave_attendance_records.append(i)
    elif type == 'total':
        leave_attendance_records = []
        for i in attendance_records:
            for j in leave_records:
                if i.member == j.member:
                    leave_attendance_records.append(i)
    else:
        leave_attendance_records = []
        for i in attendance_records:
            for j in leave_records:
                if i.member == j.member and j.leave_type is not None and j.leave_type.name == type:
                    leave_attendance_records.append(i) 
    context = {
        'attendance_records': leave_attendance_records,
        'leave_records': leave_records,
        'date': date,
    }
    return render(request,'dashboard/attendance_report.html',context)





#Company
@role_required('read_company_battalion')
def read_company_battalion(request):
    context = {
        'companyTable':Company.objects.filter(battalion=request.user.battalion) 
    }
    return render(request,'admin/company_table.html',context)



#TODO: Trans Coy
@role_required('read_trans_coy_battalion')
def read_trans_coy_battalion(request):
    battalion = request.user.battalion
    companies = battalion.companies.all()
    trans_coy = TransCoy.objects.filter(member__company__in=companies).order_by('-created_at', '-id')
    search_query = request.GET.get("search", "")  # Get search query
    members = Member.objects.filter(active=True, company__in=companies).order_by('id')
    if search_query:
        # Use Q objects for OR logic
        trans_coy = trans_coy.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(trans_coy, 50)  # 50 records per page
    page_number = request.GET.get('page')
    trans_coy = paginator.get_page(page_number)
    context = {
        "trans_coy":trans_coy,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "companies":companies
    }
    return render(request,'battalion/trans_coy_table.html',context)
   
@role_required('create_trans_coy_battalion')
def create_trans_coy_battalion(request):
    today = get_custom_today()
    battalion = request.user.battalion
    companies = battalion.companies.all()
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        new_company_id = request.POST.get('company')
        reason = request.POST.get('reason')

        # Check if all fields are provided
        if not all([army_no]):
            messages.error(request, "All fields are required")
            return redirect('read_trans_coy_battalion')
        # Check if the member exists
        if not Member.objects.filter(army_no=army_no, company__in=companies).exists():
            messages.error(request, "Member does not exist")
            return redirect('read_trans_coy_battalion')
        member = Member.objects.get(army_no=army_no)
        new_company = Company.objects.get(id=new_company_id)
        if member.company == new_company:
            messages.error(request, "Member is already in the company")
            return redirect('read_trans_coy_battalion')
        try:
            TransCoy.objects.create(
                member=member,
                date = today,
                old_company=member.company,
                new_company=new_company,
                reason = reason,
            )
            member.company = new_company
            member.save()
            messages.success(request, f"✅ {member.name} has been Transferred to {new_company.name}")
            return redirect('read_trans_coy_battalion')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_trans_coy_battalion')
        
    return render(request,'battalion/trans_coy_table.html') 




#TODO:ERE TYPE TWO
@role_required('read_ere_type_two_battalion')
def read_ere_type_two_battalion(request):
    battalion = request.user.battalion
    battalions= Battalion.objects.all().exclude(id=battalion.id)
    companies = battalion.companies.all()
    ere_type_two = EreTypeTwo.objects.filter(Q(member__company__in=companies)|Q(member__p_company__in=companies)).exclude(member__t_company__in=companies).order_by('-created_at', '-id')
    search_query = request.GET.get("search", "")  # Get search query
    members = Member.objects.filter(active=True, company__in=companies).exclude(t_company__in=companies).order_by('id')
    if search_query:
        # Use Q objects for OR logic
        ere_type_two = ere_type_two.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(ere_type_two, 50)  # 50 records per page
    page_number = request.GET.get('page')
    ere_type_two = paginator.get_page(page_number)
    context = {
        "ere_type_two":ere_type_two,
        "search_query": search_query,  # Pass search query to template
        "members":members,
        "companies":companies,
        "battalions":battalions
    }
    return render(request,'battalion/ere_type_two_table.html',context)

@role_required('create_ere_type_two_battalion')
def create_ere_type_two_battalion(request):
    today = get_custom_today()
    battalion = request.user.battalion
    companies = battalion.companies.all()
    if request.method == 'POST':
        army_no = request.POST.get('army_no')
        new_company_id = request.POST.get('company')
        reason = request.POST.get('reason')

        # Check if all fields are provided
        if not all([army_no, new_company_id]):
            messages.error(request, "Army no fields are required")
            return redirect('read_ere_type_two_battalion')
        # Check if the member exists
        if not Member.objects.filter(army_no=army_no, company__in=companies).exclude(t_company__in=companies).exists():
            messages.error(request, "Member has been ERE from other battalion")
            return redirect('read_ere_type_two_battalion')
        member = Member.objects.get(army_no=army_no)
        old_company = member.company
        #check member exits in out of unit employee
        if OutOfUnitEmp.objects.filter(member=member,status=True).exists():
            messages.error(request, "Member already exists in out of unit employee")
            return redirect('read_ere_type_two_battalion')
        #check member exits in ere type two
        if EreTypeTwo.objects.filter(member=member,status=True).exists():
            messages.error(request, "Member already exists in Ere type two")
            return redirect('read_ere_type_two_battalion')
        new_company = Company.objects.get(id=new_company_id)
        if member.company.battalion == new_company.battalion:
            messages.error(request, "Member is already in the Battalion")
            return redirect('read_ere_type_two_battalion')
        try:
            EreTypeTwo.objects.create(
                member=member,
                start_date = today,
                from_company=member.company,
                to_company=new_company,
                reason = reason,
                status=True
            )
            member.p_company = old_company
            member.t_company = new_company
            member.company = new_company
            member.save()
            messages.success(request, f"✅ {member.name} has been ERE to {new_company.name}")
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_ere_type_two_battalion')
        type_name = 'ere'

        try:
            out_of_unit_emp = OutOfUnitEmp.objects.create(member=member,type_name=type_name,start_date=today)
            out_of_unit_emp.reason = reason
            out_of_unit_emp.unit = new_company.battalion.name
            out_of_unit_emp.status = True
            out_of_unit_emp.save()
            # Create a MovementOrder entry
            movement_order = MovementOrder.objects.create(member=member, movement_type=type_name, start_date=today)
            movement_order.show_movement_type = out_of_unit_emp.get_type_name_display()
            movement_order.status = 'out'
            movement_order.unit = new_company.battalion.name
            movement_order.reason = reason
            movement_order.save()
            messages.success(request, f"✅ {member.name} has been added to out of unit employee")
            return redirect('read_ere_type_two_battalion')
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_ere_type_two_battalion')
    return redirect('read_ere_type_two_battalion')

@role_required('remove_ere_type_two_battalion')
def remove_ere_type_two_battalion(request,id):
    ere_type_two = EreTypeTwo.objects.get(id=id)
    member = ere_type_two.member
    out_of_unit_emp = OutOfUnitEmp.objects.get(member=member,status=True)
    if request.method == 'POST':
        reason = request.POST.get('reason')
        try:
            ere_type_two.end_date = get_custom_today()
            ere_type_two.status = False
            ere_type_two.save()
            member.company = ere_type_two.from_company
            member.p_company = None
            member.t_company = None
            member.save()
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_ere_type_two_battalion')
        try:
            out_of_unit_emp.end_date = get_custom_today()
            out_of_unit_emp.status = False
            out_of_unit_emp.save()
            # create movement order
            movement_order = MovementOrder.objects.create(member=member,start_date=out_of_unit_emp.start_date,end_date=get_custom_today(),reason=reason,status="in",movement_type=out_of_unit_emp.type_name, show_movement_type=out_of_unit_emp.get_type_name_display())
            messages.success(request, f"✅ {member.name} has been removed from out of unit employee")
        except Exception as e:
            messages.error(request, "An error occurred")
            print(e)
            return redirect('read_ere_type_two_battalion')
    return redirect('read_ere_type_two_battalion')