views.py

import mimetypes
import os
from io import BytesIO

import django
import pandas as pd
from django.conf import settings
from django.contrib import messages
from django.core.exceptions import PermissionDenied
from django.core.paginator import Paginator
from django.db.models import Q
from django.http import (Http404, HttpResponse, HttpResponseRedirect,
                         JsonResponse)
from django.shortcuts import get_object_or_404, redirect
from django.template import loader
from django.urls import reverse
from django.views import defaults
from django.views.generic import TemplateView

from app.forms import SuntingProfilForm, UploadMateriForm, RatingContributorForm
from app.models import (
    Category,
    Comment,
    Materi,
    ReqMaterial,
    Rating,
)
from authentication.models import User
from .services import DafterKatalogService, DetailMateriService, LikeDislikeService, MateriFieldValidationHelperService, \
    DownloadViewMateriHelperService, UploadMateriService, EditProfileService, RevisiMateriService, \
    DownloadHistoryService, GoogleDriveUploadService
from django.contrib.auth.views import PasswordChangeForm
from django.urls import reverse_lazy
from django.contrib.auth.views import PasswordChangeView
from django.shortcuts import render


def permission_denied(request, exception, template_name="error_403.html"):
    return defaults.permission_denied(request, exception, template_name)


class DaftarKatalog(TemplateView):
    paginate_by = 2
    template_name = "app/katalog_materi.html"

    def get_context_data(self, **kwargs):
        return super().get_context_data(**kwargs)

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        context["kategori_list"] = Category.objects.all()

        lstMateri = Materi.objects.filter(status="APPROVE").order_by("date_modified")
        url = ""

        lstMateri, url = DafterKatalogService.apply_options(lstMateri, request, url)


        context["materi_list"] = lstMateri
        paginator = Paginator(context["materi_list"], 15)
        page_number = request.GET.get("page")
        page_obj = paginator.get_page(page_number)
        context["materi_list"] = page_obj

        context["url"] = url
        return self.render_to_response(context=context)


class KatalogPerKontributorView(TemplateView):
    template_name = "app/katalog_kontri.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        contributor = get_object_or_404(User, email=kwargs["email"])
        context["contributor"] = contributor
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        materi_list = Materi.objects.filter(status="APPROVE", uploader=context["contributor"]).order_by(
            "date_modified"
        )

        paginator = Paginator(materi_list, 15)
        page_number = request.GET.get("page")
        materi_list_by_page = paginator.get_page(page_number)
        context["materi_list"] = materi_list_by_page
        contributor = get_object_or_404(User, email=kwargs["email"])
        context["form_rating"] = RatingContributorForm(initial={"user": contributor})
        return self.render_to_response(context=context)

    def post(self, request, *args, **kwargs):
        data = RatingContributorForm(request.POST)
        if data.is_valid():
            data.save()
        return redirect("katalog-per-kontributor", email=kwargs["email"])


class DetailMateri(TemplateView):
    template_name = "app/detail_materi.html"

    def get_context_data(self, **kwargs):
        context = super(DetailMateri, self).get_context_data(**kwargs)
        if not self.request.session or not self.request.session.session_key:
            self.request.session.save()
        materi = get_object_or_404(Materi, pk=kwargs["pk"])
        DetailMateriService.init_context_data(context, materi, self.request.session)
        published_date = DetailMateriService.set_published_date(materi)
        DetailMateriService.init_citation_and_materi_rating(context, materi, published_date, self.request)

        if self.request.user.is_authenticated:
            materi_rating = Rating.objects.filter(materi=materi, user=self.request.user).first()
            if materi_rating is not None:
                context['materi_rating_score'] = materi_rating.score
        
        context['is_authenticated'] = self.request.user.is_authenticated

        return context


    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        query_set_for_comment = Comment.objects.filter(materi=context["materi_data"])
        has_disliked, has_liked = DetailMateriService.find_comment_like_dislike(query_set_for_comment, self.request.session)
        context["comment_data"] = query_set_for_comment
        context["has_liked"] = has_liked
        context["has_disliked"] = has_disliked
        return self.render_to_response(context=context)



    def post(self, request, *args, **kwargs):
        commentText = request.POST.get("comment", None)
        if commentText == None or commentText == "":
            context = self.get_context_data(*args, **kwargs)
            context["error_message"] = "Anda belum menuliskan komentar"
            context["materi_data"] = get_object_or_404(Materi, pk=kwargs["pk"])
            query_set_for_comment = Comment.objects.filter(materi=context["materi_data"])
            context["comment_data"] = query_set_for_comment
            return self.render_to_response(context=context)

        materi = get_object_or_404(Materi, pk=kwargs["pk"])
        user_obj = request.user if request.user.is_authenticated else None
        if user_obj:
            comment = Comment.objects.create(
                comment=commentText, username=DetailMateriService.get_user_name(request), materi=materi, user=user_obj
            )
            comment.save()
        return HttpResponseRedirect(request.path)


def toggle_like(request):
    if request.method == "POST":
        materi_id = request.POST.get("materi_id", None)
        session_id = request.POST.get("session_id", None)
        if materi_id is None or session_id is None:
            return JsonResponse({"success": False, "msg": "Missing parameter"})
        return JsonResponse(LikeDislikeService.apply_like_materi(materi_id, session_id))
    else:
        return JsonResponse({"success": False, "msg": "Unsuported method"})


def delete_comment(request, pk_materi, pk_comment):
    if not request.user.is_authenticated or not request.user.is_admin:
        raise PermissionDenied(request)
    comment = get_object_or_404(Comment, pk=pk_comment)
    url = "/materi/" + str(pk_materi) + "/"
    comment.delete()
    return HttpResponseRedirect(url)

def toggle_like_comment(request):
    comment_id = 0
    if request.method == "POST":
        comment_id = request.POST.get("comment_id", None)
        session_id = request.POST.get("session_id", None)
        if comment_id is None or session_id is None:
            return JsonResponse({"success": False, "msg": "Missing parameter", "comment_id": comment_id})
        return JsonResponse(LikeDislikeService.apply_comment_like(comment_id, session_id))
    else:
        return JsonResponse({"success": False, "msg": "Unsuported method", "comment_id": comment_id})


def toggle_dislike_comment(request):
    comment_id = 0
    if request.method == "POST":
        comment_id = request.POST.get("comment_id", None)
        session_id = request.POST.get("session_id", None)
        if comment_id is None or session_id is None:
            return JsonResponse({"success": False, "msg": "Missing parameter", "comment_id": comment_id})
        return JsonResponse(LikeDislikeService.apply_comment_dislike(comment_id, session_id))
    else:
        return JsonResponse({"success": False, "msg": "Unsuported method", "comment_id": comment_id})


def add_rating_materi(request):
    if request.method == "POST" and request.user.is_authenticated:

        materi_id = request.POST.get("materi_id", None)
        rating_score = request.POST.get("rating_score", None)


        is_valid_params, materi_id, \
        rating_score, response, \
        status_code = MateriFieldValidationHelperService.\
            validate_materi_rating_params(materi_id,rating_score)

        if not is_valid_params:
            return JsonResponse(response, status=status_code)

        is_valid_rating, materi, \
        response, status_code = MateriFieldValidationHelperService.\
            validate_materi_rating(materi_id, request.user)

        if not is_valid_rating:
            return JsonResponse(response, status=status_code)

        Rating(materi=materi, user=request.user, score=rating_score).save()
        return JsonResponse(
            {"success": True, "msg": "Rating successfully created", "rating_score": rating_score}, status=201
        )
    return JsonResponse({"success": False, "msg": "Forbidden"}, status=403)



def download_materi(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
        try:
            mimetype = mimetypes.guess_type(file_path)
            with open(file_path, "rb") as fh:
                return DownloadViewMateriHelperService.build_materi_response(fh, file_path,
                                                                             materi, mimetype, request,
                                                                             HttpResponse(fh.read(), content_type=mimetype[0]))
        except Exception as e:
            raise Http404("File tidak dapat ditemukan.")
    else:
        raise Http404("File tidak dapat ditemukan.")


def view_materi(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
        mimetype = mimetypes.guess_type(file_path)
        try:
            with open(file_path, "rb") as fh:
                response = HttpResponse(fh.read(), content_type=mimetype[0])
                DownloadViewMateriHelperService.build_view_materi_response(file_path, materi, response)
                return response
        except Exception as e:
            raise Http404("File tidak dapat ditemukan.")
    else:
        raise Http404("File tidak dapat ditemukan.")


def delete_materi(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    if request.user.is_superuser or request.user.is_admin:
        materi.soft_delete()
        return HttpResponseRedirect("/administration/")
    materi.delete()
    return HttpResponseRedirect("/dashboard/")

class UploadMateriView(TemplateView):
    template_name = "unggah.html"
    context = {}

    def get_context_data(self, **kwargs):
        context = super(UploadMateriView, self).get_context_data(**kwargs)
        return context

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated == False or not request.user.is_contributor:
            raise PermissionDenied(request)
        form = UploadMateriForm(request.POST, request.FILES)
        if form.is_valid():
            materi = form.save(commit=False)
            materi.uploader = request.user
            konten = form.cleaned_data["content"]
            if not UploadMateriService.validate_file_extension(konten, request):
                return HttpResponseRedirect("/unggah/")
            UploadMateriService.upload_materi(form, materi)
            messages.success(request, "Materi berhasil diunggah, periksa riwayat unggah anda")
            return HttpResponseRedirect("/unggah/")
        else:
            context = self.get_context_data(**kwargs)
            context["form"] = form
            messages.error(request, "Terjadi kesalahan pada pengisian data")
            return self.render_to_response(context)



    def get(self, request, *args, **kwargs):
        if request.user.is_authenticated == False or not request.user.is_contributor:
            raise PermissionDenied(request)

        context = self.get_context_data(**kwargs)
        context["form"] = UploadMateriForm
        return self.render_to_response(context)




class UploadMateriHTML(TemplateView):
    template_name = "unggah.html"
    context = {}

    def get_template_names(self):
        if self.request.path == "/unggah/":
            template_name = "unggah.html"
        return template_name


class UploadMateriExcelView(TemplateView):
    template_name = "unggah_excel.html"
    context = {}

    def get_template_names(self):
        if self.request.path == "/unggah_excel/":
            template_name = "unggah_excel.html"
        return template_name

    def get(self, request, *args, **kwargs):

        if "template" in self.request.GET:

            data_frame = pd.DataFrame(
                {"Title": [], "Author": [], "Publisher": [], "Categories": [], "Description": [],}
            )

            with BytesIO() as b:
                writer = pd.ExcelWriter(b, engine="xlsxwriter")  # pylint: disable=abstract-class-instantiated
                data_frame.to_excel(writer, index=0)
                writer.save()
                response = HttpResponse(
                    b.getvalue(), content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
                )

                response["Content-Disposition"] = "attachment; filename=template.xlsx"

                return response

        else:
            context = self.get_context_data(**kwargs)
            return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        excel_file = request.FILES["excel"]
        excel = pd.read_excel(excel_file)

        row, lines = excel.shape
        categories = Category.objects.all()

        field_length = {
            "title": 50,
            "author": 30,
            "publisher": 30,
        }

        message = None

        # First pass, validate input
        for i in range(row):

            # Validate Categories
            message = UploadMateriService.validate_excel_categories(categories, excel, i, message)

            message = UploadMateriService.validate_excel_field_length(excel, field_length, i, message)

            if message != None:
                break

        if message != None:
            messages.error(request, message)
            return HttpResponseRedirect("/unggah_excel/")

        # Second pass, save data
        with django.db.transaction.atomic():
            UploadMateriService.upload_materi_excel(categories, excel, request, row)

        messages.success(request, "Materi berhasil diunggah")

        return HttpResponseRedirect("/unggah_excel/")




class DashboardKontributorView(TemplateView):
    template_name = "dashboard.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated or not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(DashboardKontributorView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(DashboardKontributorView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        current_user = self.request.user
        materi_list = current_user.materi_set.all()
        context["materi_list"] = materi_list
        return self.render_to_response(context)


class ProfilView(TemplateView):
    template_name = "profil.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            raise PermissionDenied(request)
        return super(ProfilView, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        current_user = request.user
        context["user"] = current_user
        return self.render_to_response(context)


class SuntingProfilView(TemplateView):
    template_name = "sunting.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            raise PermissionDenied(request)
        return super(SuntingProfilView, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        current_user = self.request.user
        context = self.get_context_data(**kwargs)
        context["user"] = current_user
        context["form"] = SuntingProfilForm(instance=current_user)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            raise PermissionDenied(request)

        current_user = self.request.user

        form = SuntingProfilForm(request.POST, request.FILES, instance=current_user)
        if form.is_valid():
            current_user.default_profile_picture = True

            # Removing exifdata from profile picture on upload
            if request.FILES:
                EditProfileService.update_profile_picture(current_user, request)
            else:
                form.save()
            return HttpResponseRedirect("/profil/")
        else:
            context = self.get_context_data(**kwargs)
            context["form"] = form
            return self.render_to_response(context)


class ReqMateriView(TemplateView):
    template_name = "req_materi.html"

    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            return HttpResponseRedirect("/login/")
        return super(ReqMateriView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(ReqMateriView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        title = request.POST.get("title", None)
        if title is None:
            return JsonResponse({"success": False, "msg": "Missing parameter"})
        ReqMaterial(title=title).save()
        return JsonResponse({"success": True, "msg": "Permintaan materi berhasil dikirimkan"})


class SuksesLoginKontributorView(TemplateView):
    template_name = "sukses_kontri.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(SuksesLoginKontributorView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SuksesLoginKontributorView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        current_user = self.request.user
        context["user"] = current_user

        return self.render_to_response(context)


class SuksesLoginAdminView(TemplateView):
    template_name = "sukses_admin.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_admin:
            raise PermissionDenied(request)
        return super(SuksesLoginAdminView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SuksesLoginAdminView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        current_user = self.request.user
        context["user"] = current_user

        return self.render_to_response(context)


class PostsView(TemplateView):

    template_name = "user_uploaded_posts.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            raise PermissionDenied(request)
        return super(PostsView, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        context = super().get_context_data(**kwargs)
        user = self.request.user

        posts = Materi.objects.filter(uploader=user).order_by("-date_created")
        posts_data = {post.id: {"data": post, "comments": []} for post in posts}

        comments = Comment.objects.filter(materi__id__in=posts_data.keys()).order_by("-timestamp")

        for comment in comments:
            posts_data[comment.materi.id]["comments"].append(comment)

        context["user"] = user
        context["posts"] = posts_data

        return self.render_to_response(context=context)


class RevisiMateriView(TemplateView):
    template_name = "revisi.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(RevisiMateriView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(RevisiMateriView, self).get_context_data(**kwargs)
        current_materi = get_object_or_404(Materi, pk=kwargs["pk"])
        context["materi"] = current_materi
        context["revisi_form"] = UploadMateriForm(instance=current_materi)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            raise PermissionDenied(request)

        current_materi = get_object_or_404(Materi, pk=kwargs["pk"])
        form = UploadMateriForm(request.POST, request.FILES, instance=current_materi)
        if form.is_valid():
            RevisiMateriService.revisi_materi(form, request)
            return HttpResponseRedirect("/dashboard/")
        else:
            context = self.get_context_data(**kwargs)
            context["form_revisi"] = form
            return self.render_to_response(context)


def pages(request):
    context = {}
    # All resource paths end in .html.
    # Pick out the html file name from the url. And load that template.
    try:

        load_template = request.path.split("/")[-1]
        template = loader.get_template(load_template)
        return HttpResponse(template.render(context, request))

    except Exception as e:

        template = loader.get_template("error-404.html")
        return HttpResponse(template.render(context, request))


class DownloadHistoryView(TemplateView):
    template_name = "download_history.html"

    def get_context_data(self, **kwargs):
        context = super(DownloadHistoryView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        if request.user.is_authenticated:
            current_user = self.request.user
            DownloadHistoryService.init_data_authenticated_user(context, current_user)
        else:
            DownloadHistoryService.init_data_guest_user(context, request)
        return self.render_to_response(context)


def save_to_gdrive(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
        GoogleDriveUploadService.upload_to_gdrive(file_path, materi.title)
    else:
        raise Http404("File tidak dapat ditemukan.")

    return HttpResponseRedirect(reverse('detail-materi', kwargs={'pk': pk}))

class MateriFavorite(TemplateView):

    template_name = "user_favorite_materi.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            raise PermissionDenied(request)
        return super(MateriFavorite, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        context = super().get_context_data(**kwargs)
        user = self.request.user

        materi = Materi.objects.filter(like=True)
        likes_data = { mat.id: { "data": mat, "comments": [] } for mat in materi }

        comments = Comment.objects \
            .filter(materi__id__in=likes_data.keys()) \
            .order_by("-timestamp")

        for comment in comments:
            likes_data[comment.materi.id]["comments"].append(comment)

        context["user"] = user
        context["likes"] = likes_data

        return self.render_to_response(context=context)

class PasswordChangeViews(PasswordChangeView):
    
    from_class = PasswordChangeForm
    success_url = reverse_lazy('password_success')

def password_success(request):
    return render(request, 'password_success.html', {})