import re
from django.db.models import Count, Q, F, Sum
from django.core.paginator import Paginator
from django.shortcuts import redirect, render
from django.db import transaction
from django.contrib import messages
from itertools import groupby

from django.urls import reverse
from account.models import *
from django.contrib.auth import get_user_model
from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta
User = get_user_model()

from .utils.decorators import role_required

#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
from django.contrib.auth.decorators import login_required


@login_required
def member_profile(request,member_id):
    # check if the user has permission to read member profile
    role = request.user.role
    if role and role.modules.filter(name='read_member_profile_admin').exists():
        if not Member.objects.filter(id=member_id).exists():
            messages.error(request, "Does not have permission")
            return redirect('home')
    elif role and role.modules.filter(name='read_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(Q(company__in=companies)|Q(p_company__in=companies), id=member_id).exists():
            messages.error(request, "Does not have permission")
            return redirect('home')
    elif role and role.modules.filter(name='read_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(Q(company=company)|Q(p_company=company), id=member_id).exists():
            messages.error(request, "Does not have permission")
            return redirect('home')
    elif role and role.modules.filter(name='read_member_profile_member').exists():
        if not Member.objects.filter(id=member_id, user=request.user).exists():
            messages.error(request, "Does not have permission")
            return redirect('home')
    else:
        return render(request, 'others/no_permission.html')
    
    today = get_custom_today()
    current_year = today.year
    # Get Year
    year = request.GET.get('year', current_year)
    member = Member.objects.get(id=member_id)
    basic_info, created = BasicInformation.objects.get_or_create(member=member)
    service_info, created = ServiceInformation.objects.get_or_create(member=member)
    special_quality_info = SpecialQualityInformation.objects.filter(member=member)
    families = FamilyInformation.objects.filter(member=member)
    educations = EducationInformation.objects.filter(member=member)

    leave_types = [key for key, label in MainLeave.CHOICE_LIST]
    allLeave = Leave.objects.filter(member=member,leave_type__name__in=leave_types,date__year=year).order_by('-created_at', '-id')
    # Group by created_at date (ignoring time)
    grouped_history = []
    for key, group in groupby(allLeave, key=lambda x: x.start_date):
        group_list = list(group)
        grouped_history.append(group_list[0])  # Take the first object from each group
        #pagination for leaveHistory
    paginator = Paginator(grouped_history, 50)
    page_number = request.GET.get('page')
    grouped_history = paginator.get_page(page_number)
        
    movement_orders = MovementOrder.objects.filter(member=member).order_by('-created_at', '-id')
    # pagination for movement orders
    paginator = Paginator(movement_orders, 50)  # 50 records per page
    page_number = request.GET.get('page')
    movement_orders = paginator.get_page(page_number)


    ops_depl = OpsDepl.objects.filter(member=member).order_by('-created_at', '-id')
    # pagination for ops_depl
    paginator = Paginator(ops_depl, 50)  # 50 records per page
    page_number = request.GET.get('page')
    ops_depl = paginator.get_page(page_number)

    
    # XXX: performance
    # promotion history
    promotions = Promotion.objects.filter(member=member).order_by('-date', '-id')
    last_promotion = Promotion.objects.filter(member=member).last()
    # pagination for punishment
    paginator = Paginator(promotions, 50)  # 50 records per page
    page_number = request.GET.get('page')
    promotions = paginator.get_page(page_number)
    
    # demotion history
    demotions = Demotion.objects.filter(member=member).order_by('-date', '-id')
    # pagination for punishment
    paginator = Paginator(demotions, 50)  # 50 records per page
    page_number = request.GET.get('page')
    demotions = paginator.get_page(page_number)
    
    # punishment history
    punishments = Punishment.objects.filter(member=member).order_by('-date', '-id')
    # pagination for punishment
    paginator = Paginator(punishments, 50)  # 50 records per page
    page_number = request.GET.get('page')
    punishments = paginator.get_page(page_number)
    
    # observation history
    observations = Observation.objects.filter(member=member).order_by('-date', '-id')
    # pagination for observation
    paginator = Paginator(observations, 50)  # 50 records per page
    page_number = request.GET.get('page')
    observations = paginator.get_page(page_number)
    # reward history
    rewards = Reward.objects.filter(member=member).order_by('-date', '-id')
    # pagination for reward
    paginator = Paginator(rewards, 50)  # 50 records per page
    page_number = request.GET.get('page')
    rewards = paginator.get_page(page_number)
    
    # pet history
    pets = PET.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    # pagination for pet
    paginator = Paginator(pets, 50)  # 50 records per page
    page_number = request.GET.get('page')
    pets = paginator.get_page(page_number)
    
    # ret history
    rets = RET.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    total_rds_ret = rets.aggregate(total_sum=Sum('total'))['total_sum'] or 0
    # pagination for ret
    paginator = Paginator(rets, 50)  # 50 records per page
    page_number = request.GET.get('page')
    rets = paginator.get_page(page_number)
    
    # gr_firing history
    gr_firings = GRFiring.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    total_gr_firing = gr_firings.aggregate(total_sum=Sum('total'))['total_sum'] or 0
    # pagination for gr_firing
    paginator = Paginator(gr_firings, 50)  # 50 records per page
    page_number = request.GET.get('page')
    gr_firings = paginator.get_page(page_number)
    
    # fd_firing history
    fd_firings = FDFiring.objects.filter(member=member,date_from__year=year).order_by('-date_from', '-id')
    # pagination for fd_firing
    paginator = Paginator(fd_firings, 50)  # 50 records per page
    page_number = request.GET.get('page')
    fd_firings = paginator.get_page(page_number)
    
    # course_shooting history
    course_shootings = CourseShooting.objects.filter(member=member,date_from__year=year).order_by('-date_from', '-id')
    # pagination for course_shooting
    paginator = Paginator(course_shootings, 50)  # 50 records per page
    page_number = request.GET.get('page')
    course_shootings = paginator.get_page(page_number)
    
    # sm history
    sms = SM.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    # pagination for sm
    paginator = Paginator(sms, 50)  # 50 records per page
    page_number = request.GET.get('page')
    sms = paginator.get_page(page_number)
    
    # aslt_course history
    aslt_courses = AsltCourse.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    # pagination for aslt_course
    paginator = Paginator(aslt_courses, 50)  # 50 records per page
    page_number = request.GET.get('page')
    aslt_courses = paginator.get_page(page_number)
    
    
    # ex_perf history
    ex_perfs = ExPerf.objects.filter(Q(date_from__year=year) | Q(date_to__year=year),member=member).order_by('-date_from', '-id')
    # pagination for ex_perf
    paginator = Paginator(ex_perfs, 50)  # 50 records per page
    page_number = request.GET.get('page')
    ex_perfs = paginator.get_page(page_number)

    aprs = APR.objects.filter(member=member).order_by('-id')

    
    
    context = {
        "member":member,
        "last_promotion":last_promotion,
        "leaves":grouped_history,
        "ops_depl":ops_depl,
        "movement_orders":movement_orders,
        "punishments":punishments,
        "promotions":promotions,
        "demotions":demotions,
        "observations":observations,
        "rewards":rewards,
        "pets":pets,
        "rets":rets,
        "total_rds_ret":total_rds_ret,
        "gr_firings":gr_firings,
        "total_gr_firing":total_gr_firing,
        "fd_firings":fd_firings,
        "course_shootings":course_shootings,
        "sms":sms,
        "aslt_courses":aslt_courses,
        "ex_perfs":ex_perfs,
        "basic_info":basic_info,
        "service_info":service_info,
        'special_quality_info':special_quality_info,
        "families":families,
        "educations":educations,
        "year":year,
        "aprs":aprs
    }
    return render(request,"profile/member_profile.html",context)


@login_required
def master_report_pdf_member(request,member_id):
    # check if the user has permission to read member profile
    role = request.user.role
    if role and role.modules.filter(name='read_member_profile_admin').exists():
        if not Member.objects.filter(id=member_id).exists():
            messages.error(request, "Does not have permission")
            return redirect('home')
    elif role and role.modules.filter(name='read_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(Q(company__in=companies)|Q(p_company__in=companies), id=member_id).exists():
            messages.error(request, "Does not have permission")
            return redirect('home')
    elif role and role.modules.filter(name='read_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(Q(company=company)|Q(p_company=company), id=member_id).exists():
            messages.error(request, "Does not have permission")
            return redirect('home')
    elif role and role.modules.filter(name='read_member_profile_member').exists():
        if not Member.objects.filter(id=member_id, user=request.user).exists():
            messages.error(request, "Does not have permission")
            return redirect('home')
    else:
        return render(request, 'others/no_permission.html')
    
    today = get_custom_today()
    current_year = today.year
    # Get Year
    year = request.GET.get('year', current_year)
    member = Member.objects.get(id=member_id)
    basic_info, created = BasicInformation.objects.get_or_create(member=member)
    service_info, created = ServiceInformation.objects.get_or_create(member=member)
    special_quality_info = SpecialQualityInformation.objects.filter(member=member)
    families = FamilyInformation.objects.filter(member=member)
    educations = EducationInformation.objects.filter(member=member)

    leave_types = [key for key, label in MainLeave.CHOICE_LIST]
    allLeave = Leave.objects.filter(member=member,leave_type__name__in=leave_types,date__year=year).order_by('-created_at', '-id')
    # Group by created_at date (ignoring time)
    grouped_history = []
    for key, group in groupby(allLeave, key=lambda x: x.start_date):
        group_list = list(group)
        grouped_history.append(group_list[0])  # Take the first object from each group
    

    

    
    
    
    # XXX: performance
    # promotion history
    promotions = Promotion.objects.filter(member=member).order_by('-date', '-id')
    last_promotion = Promotion.objects.filter(member=member).last()
    
    # demotion history
    demotions = Demotion.objects.filter(member=member).order_by('-date', '-id')
    
    # punishment history
    punishments = Punishment.objects.filter(member=member).order_by('-date', '-id')
    
    observations = Observation.objects.filter(member=member).order_by('-date', '-id')
    
    
    # pet history
    pets = PET.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    
    # ret history
    rets = RET.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    total_rds_ret = rets.aggregate(total_sum=Sum('total'))['total_sum'] or 0

    # gr_firing history
    gr_firings = GRFiring.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    total_gr_firing = gr_firings.aggregate(total_sum=Sum('total'))['total_sum'] or 0

    # sm history
    sms = SM.objects.filter(member=member,date__year=year).order_by('-date', '-id')
    
    # ex_perf history
    ex_perfs = ExPerf.objects.filter(Q(date_from__year=year) | Q(date_to__year=year),member=member).order_by('-date_from', '-id')


    context = {
        "member":member,
        "last_promotion":last_promotion,
        "leaves":grouped_history,
        "punishments":punishments,
        "promotions":promotions,
        "demotions":demotions,
        "observations":observations,
        "pets":pets,
        "rets":rets,
        "total_rds_ret":total_rds_ret,
        "total_gr_firing":total_gr_firing,
        "gr_firings":gr_firings,
        "sms":sms,
        "ex_perfs":ex_perfs,
        "basic_info":basic_info,
        "service_info":service_info,
        'special_quality_info':special_quality_info,
        "families":families,
        "educations":educations,
        "year":year,
    }
    # Load the HTML template and render it with context data
    template = get_template('profile/master_report_pdf_member.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_member_{member.army_no}.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



@login_required
def update_member_basic_info(request,id):
    # check if the user has permission to read member profile
    role = request.user.role
    if role and role.modules.filter(name='read_member_profile_admin').exists():
        if not Member.objects.filter(id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(Q(company__in=companies)|Q(p_company__in=companies), id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(Q(company=company)|Q(p_company=company), id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_member').exists():
        if not Member.objects.filter(id=id, user=request.user).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    else:
        return render(request, 'others/no_permission.html')
    
    
    
    member = Member.objects.get(id=id)
    blood_groups = [(key,value) for key, value in BasicInformation.BLOOD_LIST]
    marital_statuses = [(key,value) for key, value in BasicInformation.MARITAL_STATUS_LIST]
    genders = [(key,value) for key, value in BasicInformation.GENDER_LIST]
    districts = District.objects.all()
    basic_info, created = BasicInformation.objects.get_or_create(member=member)
    if request.method == 'POST':
        blood = request.POST.get('blood')
        email = request.POST.get('email')
        nid = request.POST.get('nid')
        birth = request.POST.get('birth')
        passport = request.POST.get('passport')
        bank = request.POST.get('bank')
        religion = request.POST.get('religion')
        height = request.POST.get('height')
        district_id = request.POST.get('district')
        upazila_id = request.POST.get('upazila')
        date_of_birth = request.POST.get('date_of_birth')
        gender = request.POST.get('gender')
        marital_status = request.POST.get('marital_status')
        em_name = request.POST.get('em_name')
        em_mobile_no = request.POST.get('em_mobile_no')
        mobile_no = request.POST.get('mobile_no')
        picture = request.FILES.get('picture')
        father_name = request.POST.get('father_name')
        mother_name = request.POST.get('mother_name')
        # Check if all fields are provided
        if not all([mobile_no]):
            messages.error(request, "Mobile No fields are required")
        try:
            if district_id:
                district = District.objects.get(id=district_id)
                basic_info.district = district
            if upazila_id:
                upazila = Upazila.objects.get(id=upazila_id)
                basic_info.upazila = upazila
            basic_info.blood = blood
            basic_info.email = email
            basic_info.nid = nid
            basic_info.birth = birth
            basic_info.passport = passport
            basic_info.bank = bank
            basic_info.religion = religion
            basic_info.height = height
            if date_of_birth:
                basic_info.date_of_birth = date_of_birth
            else:
                basic_info.date_of_birth = None
            basic_info.gender = gender
            basic_info.marital_status = marital_status
            basic_info.em_name = em_name
            basic_info.em_mobile_no = em_mobile_no
            member.mobile_no = mobile_no
            if picture:
                member.picture = picture
            basic_info.father_name = father_name
            basic_info.mother_name = mother_name
            basic_info.save()
            member.save() 
            messages.success(request, "Basic Information Updated Successfully")
        except Exception as e:
            messages.error(request, "An error occurred while updating basic information")
            print("error",e)
        return redirect('member_profile',member_id=id)
    context = {
        "member":member,
        "blood_groups":blood_groups,
        "marital_statuses":marital_statuses,
        "genders":genders,
        "districts":districts,
        "basic_info":basic_info
    }
    return render(request,'profile/edit_basic.html',context)

@login_required
def update_member_service_info(request,id):
    # check if the user has permission to read member profile
    role = request.user.role
    if role and role.modules.filter(name='read_member_profile_admin').exists():
        if not Member.objects.filter(id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(Q(company__in=companies)|Q(p_company__in=companies), id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(Q(company=company)|Q(p_company=company), id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_member').exists():
        if not Member.objects.filter(id=id, user=request.user).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    else:
        return render(request, 'others/no_permission.html')
    
    
    
    
    member = Member.objects.get(id=id)
    med_cats = ServiceInformation.MED_CAT_LIST
    un_msns = ServiceInformation.UN_MSN_LIST
    trades = Trade.objects.all()
    cores = Core.objects.all()
    batches = Batch.objects.all().order_by('-id')
    service, created = ServiceInformation.objects.get_or_create(member=member)
    if request.method == 'POST':
        med_cat = request.POST.get('med_cat')
        un_msn = request.POST.get('un_msn')
        trade_id = request.POST.get('trade')
        core_id = request.POST.get('core')
        batch_id = request.POST.get('batch')
        retirement = request.POST.get('retirement')
        doe = request.POST.get('doe')
        try:
            if trade_id:
                trade = Trade.objects.get(id=trade_id)
                service.trade = trade
            if core_id:
                core = Core.objects.get(id=core_id)
                service.core = core
            if batch_id:
                batch = Batch.objects.get(id=batch_id)
                service.batch = batch
            service.med_cat = med_cat
            service.un_msn = un_msn
            if doe:
                service.doe = doe
            else:
                service.doe = None
            if retirement:
                service.retirement = retirement
            else:
                service.retirement = None
            service.save()
            messages.success(request, "Service Information Updated Successfully")
        except Exception as e:
            messages.error(request, "An error occurred while updating Service information")
            print("error",e)
        return redirect('member_profile',member_id=id)
    context = {
        "member":member,
        "med_cats":med_cats,
        "un_msns":un_msns,
        "trades":trades,
        "cores":cores,
        "batches":batches,
        "service":service
    }
    return render(request,'profile/edit_service.html',context)

@login_required
def create_special_quality_info(request,id):
    # check if the user has permission to read member profile
    role = request.user.role
    if role and role.modules.filter(name='read_member_profile_admin').exists():
        if not Member.objects.filter(id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(Q(company__in=companies)|Q(p_company__in=companies), id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(Q(company=company)|Q(p_company=company), id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_member').exists():
        if not Member.objects.filter(id=id, user=request.user).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    else:
        return render(request, 'others/no_permission.html')
    
    
    member = Member.objects.get(id=id)
    special_quality_info = SpecialQualityInformation.objects.filter(member=member)
    special_qualities = SpecialQuality.objects.all()
    if request.method == 'POST':
        special_quality_id = request.POST.get('special_quality')
        description = request.POST.get('description')
        # Check if all fields are provided
        if not all([special_quality_id]):
            messages.error(request, "FIll Name fields")
        try:
            special_quality = SpecialQuality.objects.get(id=special_quality_id)
            SpecialQualityInformation.objects.create(member=member,special_quality=special_quality,description=description)
            messages.success(request, "SpecialQuality Information Added Successfully")
        except Exception as e:
            messages.error(request, "An error occurred while adding family information")
        return redirect('create_special_quality_info',id=id)
    context = {
        "member":member,
        "special_quality_info":special_quality_info,
        "special_qualities":special_qualities
    }
    return render(request,'profile/add_special_quality_info.html',context)

@login_required
def delete_special_quality_info(request,id):
    special_quality_info = SpecialQualityInformation.objects.get(id=id)
    member = special_quality_info.member
    # check if the user has permission to update member profile
    role = request.user.role
    if role and role.modules.filter(name='update_member_profile_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_member').exists():
        if not Member.objects.filter(id=id, user=request.user).exists():
            messages.error(request, "Member does not have permission.")
            return redirect('member_profile', member_id=id)
        
    special_quality_info.delete()
    messages.success(request, "Special Quality Information Deleted Successfully")
    return redirect('create_special_quality_info',id=special_quality_info.member.id)

@login_required
def create_family_info(request,id):
    member = Member.objects.get(id=id)
    # check if the user has permission to update member profile
    role = request.user.role
    if role and role.modules.filter(name='update_member_profile_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_member').exists():
        if not Member.objects.filter(id=id, user=request.user).exists():
            messages.error(request, "Member does not have permission.")
            return redirect('member_profile', member_id=id)
        
        
    relations = [(key,value) for key, value in FamilyInformation.REL_LIST] 
    genders = [(key,value) for key, value in FamilyInformation.GENDER_LIST]
    families = FamilyInformation.objects.filter(member=member)
    if request.method == 'POST':
        relationship = request.POST.get('relationship')
        name = request.POST.get('name')
        nid = request.POST.get('nid')
        birth = request.POST.get('birth')
        date_of_birth = request.POST.get('date_of_birth')
        gender = request.POST.get('gender')
        occupation = request.POST.get('occupation')
        mobile_no = request.POST.get('mobile_no')
        picture = request.FILES.get('picture')
        # Check if all fields are provided
        if not all([name,relationship,gender]):
            messages.error(request, "FIll all fields")

        if not picture:
            picture = None
        try:
            FamilyInformation.objects.create(member=member,relationship=relationship,name=name,nid=nid,birth=birth,date_of_birth=date_of_birth,gender=gender,mobile_no=mobile_no,occupation=occupation,picture=picture)
            messages.success(request, "Family Information Added Successfully")
        except Exception as e:
            messages.error(request, "An error occurred while adding family information")
        return redirect('create_family_info',id=id)
    context = {
        "member":member,
        "relations":relations,
        "genders":genders,
        "families":families
    }
    return render(request,'profile/add_family.html',context)

@login_required
def update_family_info(request,id):
    family = FamilyInformation.objects.get(id=id)
    member = family.member
    # check if the user has permission to update member profile
    role = request.user.role
    if role and role.modules.filter(name='update_member_profile_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=member.id)
    elif role and role.modules.filter(name='update_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=member.id)
    elif role and role.modules.filter(name='update_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=member.id)
    elif role and role.modules.filter(name='update_member_profile_member').exists():
        if not Member.objects.filter(id=member.id, user=request.user).exists():
            messages.error(request, "Member does not have permission.")
            return redirect('member_profile', member_id=member.id)
        
        
    relations = [(key,value) for key, value in FamilyInformation.REL_LIST] 
    genders = [(key,value) for key, value in FamilyInformation.GENDER_LIST]
    if request.method == 'POST':
        relationship = request.POST.get('relationship')
        name = request.POST.get('name')
        nid = request.POST.get('nid')
        birth = request.POST.get('birth')
        date_of_birth = request.POST.get('date_of_birth')
        gender = request.POST.get('gender')
        occupation = request.POST.get('occupation')
        mobile_no = request.POST.get('mobile_no')
        picture = request.FILES.get('picture')
        # Check if all fields are provided
        if not all([name,relationship,gender]):
            messages.error(request, "FIll all fields")

        if not picture:
            picture = None

        try:
            family.relationship = relationship
            family.name = name
            family.nid = nid
            family.birth = birth
            family.date_of_birth = date_of_birth
            family.gender = gender
            family.mobile_no = mobile_no
            family.occupation = occupation
            if picture:
                family.picture = picture
            family.save()
            messages.success(request, "Family Information Updated Successfully")
        except Exception as e:
            messages.error(request, "An error occurred while updating family information")
        return redirect('member_profile',member_id=member.id)
    context = {
        "member":member,
        "family":family,
        "relations":relations,
        "genders":genders
    }
    return render(request,'profile/update_family.html',context)

@login_required
def delete_family_info(request,id):
    family = FamilyInformation.objects.get(id=id)
    member = family.member
    # check if the user has permission to update member profile
    role = request.user.role
    if role and role.modules.filter(name='update_member_profile_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_member').exists():
        if not Member.objects.filter(id=id, user=request.user).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    else:
        return render(request, 'others/no_permission.html')
    
    # Delete the family information
    family.delete()
    messages.success(request, "Family Information Deleted Successfully")
    return redirect('create_family_info',id=family.member.id)


@login_required
def create_education_info(request,id):
    # check if the user has permission to read member profile
    role = request.user.role
    if role and role.modules.filter(name='read_member_profile_admin').exists():
        if not Member.objects.filter(id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(Q(company__in=companies)|Q(p_company__in=companies), id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(Q(company=company)|Q(p_company=company), id=id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='read_member_profile_member').exists():
        if not Member.objects.filter(id=id, user=request.user).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    else:
        return render(request, 'others/no_permission.html')
    
    
    
    member = Member.objects.get(id=id)
    educations = EducationInformation.objects.filter(member=member)
    if request.method == 'POST':
        name = request.POST.get('name')
        institution = request.POST.get('institution')
        year = request.POST.get('year')
        gpa = request.POST.get('gpa')
        # Check if all fields are provided
        if not all([name]):
            messages.error(request, "FIll Name fields")
        try:
            EducationInformation.objects.create(member=member,name=name,year=year,gpa=gpa,institution=institution)
            messages.success(request, "Education Information Added Successfully")
        except Exception as e:
            messages.error(request, "An error occurred while adding family information")
        return redirect('create_education_info',id=id)
    context = {
        "member":member,
        "educations":educations
    }
    return render(request,'profile/add_education.html',context)

@login_required
def update_education_info(request, id):
    education = EducationInformation.objects.get(id=id)
    member = education.member
        # check if the user has permission to update member profile
    role = request.user.role
    if role and role.modules.filter(name='update_member_profile_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=member.id)
    elif role and role.modules.filter(name='update_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=member.id)
    elif role and role.modules.filter(name='update_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=member.id)
    elif role and role.modules.filter(name='update_member_profile_member').exists():
        if not Member.objects.filter(id=member.id, user=request.user).exists():
            messages.error(request, "Member does not have permission.")
            return redirect('member_profile', member_id=member.id)
        

    if request.method == 'POST':
        name = request.POST.get('name')
        institution = request.POST.get('institution')
        year = request.POST.get('year')
        gpa = request.POST.get('gpa')
        # Check if all fields are provided
        if not all([name]):
            messages.error(request, "Name is required")
        try:
            education.name = name
            education.institution = institution
            education.year = year
            education.gpa = gpa
            education.save()
            messages.success(request, "Education Information Updated Successfully")
        except Exception as e:
            messages.error(request, "An error occurred while updating education information")
        return redirect('member_profile', member_id=member.id)
    context = {
        "member": member,
        "education": education
    }
    return render(request, 'profile/update_education.html', context)

@login_required
def delete_education_info(request,id):
    education = EducationInformation.objects.get(id=id)
    member = education.member
    # check if the user has permission to update member profile
    role = request.user.role
    if role and role.modules.filter(name='update_member_profile_admin').exists():
        if not Member.objects.filter(id=member.id).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_battalion').exists():
        companies = request.user.battalion.companies.all()
        if not Member.objects.filter(id=member.id, company__in=companies).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_company').exists():
        company = request.user.company
        if not Member.objects.filter(id=member.id, company=company).exists():
            messages.error(request, "Does not have permission")
            return redirect('member_profile', member_id=id)
    elif role and role.modules.filter(name='update_member_profile_member').exists():
        if not Member.objects.filter(id=id, user=request.user).exists():
            messages.error(request, "Member does not have permission.")
            return redirect('member_profile', member_id=id)
    else:
        return render(request, 'others/no_permission.html')
    # Delete the education information
    education.delete()
    messages.success(request, "Family Information Deleted Successfully")
    return redirect('create_education_info',id=member.id)