import math

class TemporaryObjectListStorage:
    primaryKey = "INVALID"

    def __init__(self):
        self._current = {}
        self._managed = {}
        self._addQueue = {}
        self._updateQueue = {}
        self._killQueue = {}

        self._primaryKey = self.primaryKey

    def loadRawData(self, rawData):
        for element in rawData:
            self._current[element[self._primaryKey]] = element
            if self._checkElementValidity(element):
                self._managed[element[self._primaryKey]] = element
                self._killQueue[element[self._primaryKey]] = element

    def addElement(self, element, elementId):
        """
        This function safely adds an element:
        - If it exists and is unchanged, it removes it from the kill queue
        - If it exists and has changed, it adds it to the update queue
        - If it is unmanaged, it retruns false
        - If it does not exist, it adds it to the add queue
        """
        if elementId in self._managed:
            if elementId in self._killQueue: 
                del self._killQueue[elementId]

            if self._checkElementChanges(element, elementId): 
                self._updateQueue[elementId] = element
                
        elif elementId in self._current:
            return False

        elif elementId not in self._addQueue:
            self._addQueue[elementId] = element

        return True

    def getQueueAsList(self, queue):
        elementList = []
        for _, value in queue.items():
            elementList.append(value)
        return elementList

    def addQueue(self):
        return self.getQueueAsList(self._addQueue)


    def updateQueue(self):
        queue = []
        for key, value in self._updateQueue.items():
            queue.append({
            "attr": value,
            "items": [key]
        })
        return queue


    def killQueue(self):
        return self.getQueueAsList(self._killQueue)

    def queuesAreEmpty(self):
        return len(self._killQueue) == 0 and len(self._addQueue) == 0 and len(self._updateQueue) == 0

    def getQueueCountsString(self, descriptor):
        return f"Going to add {len(self._addQueue)} {descriptor}, update {len(self._updateQueue)} {descriptor} and kill {len(self._killQueue)} {descriptor}"

    def _checkElementChanges(self, element, elementId):
        """
        Checks if an element has changed
        :returns: True if changed, False if not
        """
        currentElement = self._managed[elementId]

        for key, value in element.items():
            if self._checkElementValueDelta(key, currentElement, value):
                #currentValue = "" if key not in currentElement else currentElement[key]
                #print(f"Found delta in {key}. Current: {currentValue} new: {value}")
                return True

        return False

    def _checkElementValueDelta(self, key, currentElement, newValue):
        return key not in currentElement or currentElement[key] != newValue

    def _checkElementValidity(self, element):
        return True