import math
from django.contrib import messages
import time
from django.http import JsonResponse
from django.shortcuts import redirect, render
from django.utils.decorators import method_decorator
from django.views import View
from django.views.decorators.cache import cache_control
from datetime import time, datetime
from rest_framework import generics, permissions, status
from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import permissions, status
from rest_framework.exceptions import NotFound
from codesofy.custom_config import get_global_master_details, get_local_date, get_privilleges, get_unique_text, is_authorized, set_menu_items, set_user_profile
from codesofy.master_details import DateFilter, PerPageSelector, PlatformType
from core.utils import get_api_message
from manageappversion.forms import AndroidVersionForm, IOSVersionForm
from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
from rest_framework.exceptions import PermissionDenied, NotFound, ValidationError
from .models import AppVersion

from django.core.paginator import Paginator
import datetime as dt
from django.utils.dateparse import parse_datetime, parse_date
from django.utils import timezone
from django.db.models import ProtectedError


menu_item = "manageappversion"



def get_local_master_details():
    context = get_global_master_details()
    return context

def set_sub_menu_item(sub_menu_item,context):
    context = set_menu_items(menu_item,sub_menu_item,context)
    return context

class HasCustomerProfile(permissions.BasePermission):
    """Allow only users who have a linked customer profile."""
    def has_permission(self, request, view):
        return getattr(request.user, "customer", None) is not None


@method_decorator(cache_control(no_cache=True, must_revalidate=True, no_store=True), name="dispatch")
class ManageAppVersionsView(View):
    this_feature = "manageappversion"
    sub_menu_item = "manageappversion"
    template_name = "manageappversion/app-version.html"

    # ----------------------------------------------------------------
    # helper: get existing platform rows
    def get_instances(self):
        android = AppVersion.objects.filter(platform=PlatformType.ANDROID.value).first()
        ios = AppVersion.objects.filter(platform=PlatformType.IOS.value).first()
        return android, ios

    # ----------------------------------------------------------------
    # GET request
    def get(self, request):
        context = {}
        user_profile = set_user_profile(request, context)
        if user_profile is None:
            return redirect("login")

        get_privilleges(user_profile, context)

        if not is_authorized(user_profile, self.this_feature):
            return redirect("unauthorized-access")

        set_sub_menu_item(self.sub_menu_item, context)

        android, ios = self.get_instances()
        if not android or not ios:
            missing = []
            if not android:
                missing.append("Android")
            if not ios:
                missing.append("iOS")
            messages.error(request, f"Missing DB row(s): {', '.join(missing)}. Create them once at DB level.")

        context.update({
            "android_form": AndroidVersionForm(instance=android, prefix="android"),
            "ios_form": IOSVersionForm(instance=ios, prefix="ios"),
            "android_missing": android is None,
            "ios_missing": ios is None,
        })
        return render(request, self.template_name, context)

    # ----------------------------------------------------------------
    # POST request
    def post(self, request):
        context = {}
        user_profile = set_user_profile(request, context)
        if user_profile is None:
            return redirect("login")

        get_privilleges(user_profile, context)
        if not is_authorized(user_profile, self.this_feature):
            return redirect("unauthorized-access")

        set_sub_menu_item(self.sub_menu_item, context)

        android, ios = self.get_instances()
        if not android or not ios:
            messages.error(request, "Create both platform rows in DB first.")
            return redirect("manageappversion:app-version")

        android_form = AndroidVersionForm(request.POST, instance=android, prefix="android")
        ios_form = IOSVersionForm(request.POST, instance=ios, prefix="ios")

        if android_form.is_valid() and ios_form.is_valid():
            android_form.save()
            ios_form.save()
            messages.success(request, "Versions updated successfully.")
            return redirect("manageappversion:app-version")

        messages.error(request, "Please fix the errors below.")

        context.update({
            "android_form": android_form,
            "ios_form": ios_form,
            "android_missing": False,
            "ios_missing": False,
        })
        return render(request, self.template_name, context)


@method_decorator(cache_control(no_cache=True, must_revalidate=True, no_store=True), name="dispatch")
class AppVersionAPIView(APIView):
    """
    GET /api/v1/app-version/?platform=android
    Returns version info for a given platform (ANDROID / IOS)
    """
    permission_classes = [permissions.AllowAny]

    def get(self, request, *args, **kwargs):
        platform_param = (request.query_params.get("platform") or "").upper().strip()

        # ✅ Validate platform
        if platform_param not in PlatformType.to_list():
            return JsonResponse(
                {
                    "success": False,
                    "message": get_api_message("INVALID_PLATFORM", request),
                    "code": "INVALID_PLATFORM",
                    "errors": {"platform": ["Must be one of ANDROID or IOS."]},
                },
                status=400,
            )

        version = AppVersion.objects.filter(platform=platform_param).first()
        if not version:
            return JsonResponse(
                {
                    "success": False,
                    "message": get_api_message("VERSION_NOT_FOUND", request),
                    "code": "VERSION_NOT_FOUND",
                    "errors": {"platform": [f"No version record found for {platform_param}."]},
                },
                status=404,
            )

        # ✅ Success
        data = {
            "platform": platform_param,
            "min_version": version.min_version,
            "latest_version": version.latest_version,
            "update_message": version.update_message or get_api_message("NEW_VERSION_AVAILABLE", request),
            "update_url": version.update_url,
        }

        return JsonResponse(
            {
                "success": True,
                "message": get_api_message("APP_VERSION_FETCHED", request),
                "code": "APP_VERSION_FETCHED",
                "data": data,
            },
            status=200,
        )
