import datetime
import json
from django.db import models
from django.utils import timezone


class KafkaLog(models.Model):
    # request data and response_data store as TextField, incase got return or send somethings in string so cant store in jsonField
    request_id = models.CharField(max_length=100,unique=True,null=True)
    request_topic = models.CharField(max_length=200, null=True)
    request_header = models.TextField(null=True, blank=True)
    request_data = models.TextField(null=True, blank=True)
    response_topic = models.CharField(max_length=200, null=True)
    response_header = models.TextField(null=True, blank=True)
    response_data = models.TextField(null=True, blank=True)
    request_at = models.DateTimeField(null=True)
    response_at = models.DateTimeField(null=True)
    extra_data = models.TextField(null=True, blank=True)
    socket_id = models.CharField(max_length=155,null=True,db_comment="remark to know need push to which socket")

    class Meta:
        db_table = 'kafka_log'

    @staticmethod
    def insert_response(request_id, response_topic, response_data, socket_id: None, response_header=None):
        if isinstance(response_data, (dict, list)):
            response_data = json.dumps(response_data)
        else:
            response_data = str(response_data)
        log = KafkaLog.objects.create(
            request_id=request_id,
            response_topic=response_topic,
            response_header=response_header,
            response_data=response_data,
            response_at=timezone.now(),
            socket_id=socket_id
        )
        return log

    @staticmethod
    def insert_request(request_id, request_topic,request_data,socket_id:None,request_header=None):
        if isinstance(request_data, (dict, list)):
            request_data = json.dumps(request_data)
        else:
            request_data = str(request_data)
        log = KafkaLog.objects.create(
            request_id=request_id,
            request_topic=request_topic,
            request_header=request_header,
            request_data=request_data,
            request_at=timezone.now(),
            socket_id=socket_id
        )
        return log.id

    @staticmethod
    def update_response(response_topic,response_data,response_header=None):
        request_not_found = True
        try:
            request_id = response_data.get('request_id')
            if isinstance(response_data, (dict, list)):
                response_data = json.dumps(response_data)
            else:
                response_data = str(response_data)

            if isinstance(response_header, (dict, list)):
                response_header = json.dumps(response_header)
            else:
                response_header = str(response_header)
            if request_id:
                log = KafkaLog.objects.filter(request_id=request_id).first()
                if log:
                    log.response_data = response_data
                    log.response_header = response_header
                    log.response_topic = response_topic
                    log.response_at = timezone.now()
                    log.save()
                    request_not_found = False
                    return log

            if request_not_found:
                # even no request id or not found the request, also store the result, just for record purpose
                KafkaLog.objects.create(
                    response_data=response_data,
                    response_topic=response_topic,
                    response_header=response_header,
                    response_at=timezone.now(),
                )

        except KafkaLog.DoesNotExist:
            pass