import datetime

from django.core.management import BaseCommand
from django.utils import timezone
from rest_framework import serializers, status

from api.models import TtSuitability, TtTag, TtSetting, AuditTrail, AuditTrailDetails, TtDepartment, TtZone, \
    TtUsagePreference, TtAcademicTerm
from api.views.admin.base import AdminApiBase
from api.validator import BaseValidator
from api.utils import decrypt_aes_128_cbc, encrypt_aes_128_cbc, log_critical_error, get_exception_detail, \
    bulk_sync_to_redis, get_ip, get_related_fk_table_ids, get_resources_affected_weeks, get_resource_map_redis_data, \
    recalculate_resource_map
from rest_framework.exceptions import ValidationError
from api.translation import __
from backend.kafka import send_request
from backend.redis_client import redis_client

class Command(BaseCommand):
    def handle(self, *args, **options):
        """
        avoid timeout problem, so using task file to delete large academic term
        """

        setting_params = {
            "slot_per_week",
        }
        # settings = TtSetting.get_multiple_setting(setting_params)
        # slot_per_week = int(settings["slot_per_week"])
        # action = "academic_term_delete"
        # at = TtAcademicTerm.objects.filter(code=65).first()
        # ids = [at.id]
        #
        # academic_term = TtAcademicTerm.objects.filter(id__in=ids)
        # academic_term_code = ",".join(academic_term.values_list("code", flat=True))
        #
        # # must get before delete, if put after delete cant get the result
        # redis_related_fk_data = get_related_fk_table_ids("TtAcademicTerm", ids, True)
        #
        # staff_with_affected_week = location_with_affected_week = student_set_with_affected_week = {}
        # staff_ids = location_ids = student_set_ids = set()
        # # before delete, need check which resources need update student set or not
        # if redis_related_fk_data:
        #     for redis_table, related_ids in redis_related_fk_data.items():
        #         if redis_table == "activity":
        #             resources_data = get_resources_affected_weeks(None, related_ids)
        #             staff_with_affected_week, staff_ids = resources_data["staff_with_affected_week"], resources_data[
        #                 "staff_ids"]
        #             location_with_affected_week, location_ids = resources_data["location_with_affected_week"], \
        #             resources_data["location_ids"]
        #             student_set_with_affected_week, student_set_ids = resources_data["student_set_with_affected_week"], \
        #             resources_data["student_set_ids"]
        #
        # TtAcademicTerm.objects.filter(id__in=ids).delete()
        #
        # # remove from redis
        # redis_academic_term_table = "academic_term"
        # redis_data = {
        #     "update": {},
        #     "delete": {}
        # }
        # redis_staff_table = "staff"
        # redis_location_table = "location"
        # redis_student_set_table = "student_set"
        # # recalculate resource map for affected_week
        # if staff_with_affected_week:
        #     recalculate_resource_map("staff", staff_with_affected_week, slot_per_week)
        #     redis_data["update"][redis_staff_table] = get_resource_map_redis_data("staff", staff_ids)
        # if location_with_affected_week:
        #     recalculate_resource_map("location", location_with_affected_week, slot_per_week)
        #     redis_data["update"][redis_location_table] = get_resource_map_redis_data("location", location_ids)
        # if student_set_with_affected_week:
        #     recalculate_resource_map("student_set", student_set_with_affected_week, slot_per_week)
        #     redis_data["update"][redis_student_set_table] = get_resource_map_redis_data("student_set", student_set_ids)
        # # delete academic_term from redis
        # for id in ids:
        #     redis_data["delete"].setdefault(redis_academic_term_table, []).append(id)
        #
        # # when delete academic_term few table data will need to delete also
        # if redis_related_fk_data:
        #     # the redis_table might having table that not inside redis also, but remain only, redis there will ignore those data
        #     for redis_table, related_ids in redis_related_fk_data.items():
        #         redis_data["delete"].setdefault(redis_table, []).extend(related_ids)
        #
        # bulk_sync_to_redis(redis_client, redis_data)
        #
        # # kafka
        # method = "academic_term_delete"
        # kafka_topic = "microservices-tt"
        # if kafka_topic:
        #     kafka_request_data = {
        #         "session_id": "",
        #         "academic_term_ids": ids
        #     }
        #     send_request(kafka_topic, kafka_request_data, None, method)