from typing import Any
from django.db import models
from django.shortcuts import render, get_object_or_404, redirect
from django.contrib.auth.mixins import LoginRequiredMixin
from accounts import resource_action
from django.views import generic
from goodtimes import constants
from django.urls import reverse_lazy
from django.contrib import messages
from .models import (
    Organization,
    NewsAndArticles,
    NewsAndArticlesCategory,
    Newsletter,
    Faqs,
    FaqCategory,
    Education,
)
from .forms import (
    OrganizationForm,
    NewsAndArticlesForm,
    NewsAndArticleCategoryForm,
    AboutUsForm,
    TermsAndConditionForm,
    PrivacyPolicyForm,
    FaqsForm,
    FaqCategoryFrom,
    EducationVideoForm,
    EducationMaterialForm,
)


class CmsDashboardView(LoginRequiredMixin, generic.TemplateView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    template_name = "manage_cms/cms_dashboard.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class NewsArticleListView(LoginRequiredMixin, generic.ListView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_READ
    template_name = "manage_cms/news_article_list.html"
    model = NewsAndArticles
    context_object_name = "news_article_obj"

    def get_queryset(self):
        return (
            super()
            .get_queryset()
            .select_related("article_category")
            .prefetch_related("tags")
            .filter(deleted=False)
        )

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        context["category_obj"] = NewsAndArticlesCategory.objects.filter(deleted=False)
        return context


class NewsArticleCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_cms/news_article_add.html"
    model = NewsAndArticles
    form_class = NewsAndArticlesForm
    success_url = reverse_lazy("manage_cms:news_article_list")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE
        print("get method of article is called")
        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE
        print("post method is called")
        form = self.form_class(request.POST, request.FILES, instance=self.object)
        print("request with files", request.FILES)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)
        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class NewsArticleDeleteView(LoginRequiredMixin, generic.View):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_DELETE
    model = NewsAndArticles
    success_url = reverse_lazy("manage_cms:news_article_list")
    success_message = constants.RECORD_DELETED
    error_message = constants.RECORD_NOT_FOUND

    def get(self, request, pk):
        try:
            type_obj = self.model.objects.get(id=pk)
            type_obj.deleted = True
            type_obj.save()
            messages.success(request, self.success_message)
        except self.model.DoesNotExist:
            messages.success(request, self.error_message)

        return redirect(self.success_url)


class NewsArticleCategoryCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_cms/news_article_category_add.html"
    model = NewsAndArticlesCategory
    form_class = NewsAndArticleCategoryForm
    success_url = reverse_lazy("manage_cms:news_article_list")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        print("Get Action called:")
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class NewsArticleCategoryDeleteView(LoginRequiredMixin, generic.View):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_DELETE
    model = NewsAndArticlesCategory
    success_url = reverse_lazy("manage_cms:news_article_list")
    success_message = constants.RECORD_DELETED
    error_message = constants.RECORD_NOT_FOUND

    def get(self, request, pk):
        try:
            type_obj = self.model.objects.get(id=pk)
            type_obj.deleted = True
            type_obj.save()
            messages.success(request, self.success_message)
        except self.model.DoesNotExist:
            messages.success(request, self.error_message)

        return redirect(self.success_url)


class NewsLetterListView(LoginRequiredMixin, generic.TemplateView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_READ
    template_name = "manage_cms/newsletter_list.html"

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)
        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class NewsLetterCreateOrUpdateView(LoginRequiredMixin, generic.TemplateView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    template_name = "manage_cms/newsletter_add.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class AboutUsView(LoginRequiredMixin, generic.DetailView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    template_name = "manage_cms/about_us_view.html"
    model = Organization
    context_object_name = "organization"

    def get_object(self, queryset=None):
        return self.model.objects.only("about_us").first()

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class AboutUsCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_cms/about_us_add.html"
    model = Organization
    form_class = AboutUsForm
    success_url = reverse_lazy("manage_cms:about_us_view")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        return self.model.objects.only("about_us").first()

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class TermsConditionView(LoginRequiredMixin, generic.DetailView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_DELETE
    template_name = "manage_cms/terms_and_condition_view.html"
    model = Organization
    context_object_name = "organization"

    def get_object(self, queryset=None):
        return self.model.objects.only("terms_condition").first()

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class TermsConditionCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_cms/terms_and_condition_edit.html"
    model = Organization
    form_class = TermsAndConditionForm
    success_url = reverse_lazy("manage_cms:terms_and_condition_view")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        return self.model.objects.only("terms_condition").first()

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class FaqListView(LoginRequiredMixin, generic.ListView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_READ
    template_name = "manage_cms/faq.html"
    model = Faqs
    context_object_name = "faqs_obj"

    def get_queryset(self):
        return super().get_queryset().filter(deleted=False)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        context["faq_category_obj"] = FaqCategory.objects.all()
        return context


class FaqCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_cms/faq_add.html"
    model = Faqs
    form_class = FaqsForm
    success_url = reverse_lazy("manage_cms:faq_list")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        print("Request data: ", request.POST)
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class FAQDeleteView(LoginRequiredMixin, generic.View):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_DELETE
    model = Faqs
    success_url = reverse_lazy("manage_cms:faq_list")
    success_message = constants.RECORD_DELETED
    error_message = constants.RECORD_NOT_FOUND

    def get(self, request, pk):
        try:
            faq_obj = self.model.objects.get(id=pk)
            faq_obj.deleted = True
            faq_obj.active = False
            faq_obj.save()
            messages.success(request, self.success_message)
        except self.model.DoesNotExist:
            messages.success(request, self.error_message)

        return redirect(self.success_url)


class FaqCategoryCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_cms/faq_category_add.html"
    model = FaqCategory
    form_class = FaqCategoryFrom
    success_url = reverse_lazy("manage_cms:faq_list")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        print("Get Action called:")
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        print("Request data: ", request.POST)
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class PrivacyPolicyView(LoginRequiredMixin, generic.DetailView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_READ
    template_name = "manage_cms/privacy_policy_view.html"
    model = Organization
    context_object_name = "organization"

    def get_object(self, queryset=None):
        return self.model.objects.only("privacy_policy").first()

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class PrivacyPolicyCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_cms/privacy_policy_edit.html"
    model = Organization
    form_class = PrivacyPolicyForm
    success_url = reverse_lazy("manage_cms:privacy_policy_view")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        return self.model.objects.only("privacy_policy").first()

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)
        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class TestimonialListView(LoginRequiredMixin, generic.TemplateView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    template_name = "manage_cms/testimonial_list.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class OrganizationView(LoginRequiredMixin, generic.DetailView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_READ
    model = Organization
    template_name = "manage_cms/organization_view.html"
    context_object_name = "organization_obj"

    def get_object(self, queryset=None):
        return self.model.objects.first()

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class OrganizationCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_cms/organization_add.html"
    model = Organization
    form_class = OrganizationForm
    success_url = reverse_lazy("manage_cms:organization_view")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        return self.model.objects.first()

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)
        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class EducationView(LoginRequiredMixin, generic.ListView):
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS
    action = resource_action.ACTION_READ
    model = Education
    template_name = "manage_cms/education_view.html"
    context_object_name = "education_obj"

    def get_queryset(self):
        return super().get_queryset().prefetch_related("tags").filter(deleted=False)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        context["video_obj"] = self.get_queryset().filter(content_type=Education.VIDEO)
        context["material_obj"] = self.get_queryset().filter(
            content_type=Education.MATERIAL
        )
        print("video data", context["video_obj"])
        return context


class EducationCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_CMS
    resource = resource_action.RESOURCE_MANAGE_CMS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action
    page_title = None

    template_name = "manage_cms/education_add.html"
    model = Education
    form_class = None
    success_url = reverse_lazy("manage_cms:education_view")

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "page_title": self.page_title,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()
        # print("response of image file", request.POST, request.FILES)

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE
        print(f"published date {request.POST.get('published_at')}")
        form = self.form_class(request.POST, request.FILES, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)
        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class EducationVideoCreateOrUpdateView(EducationCreateOrUpdateView):
    page_title = "Video"
    form_class = EducationVideoForm


class EducationMaterialCreateOrUpdateView(EducationCreateOrUpdateView):
    page_title = "Material"
    form_class = EducationMaterialForm