from collections import namedtuple
from enum import enum
from datetime import datetime
import threading
import socket
import json

##################################################################################################################################
# Daniels Mysteriska Notes                                                                                                       #
##################################################################################################################################
#Vissa saker kan vara redundanta, om du hittar något så skicka koden som är motsägande till mig på Discord
#Om jag inte ser det direkt eller tar lite tid att svara så föröska kolla på något annat

#Kom ihåg att python har bra documentation för saker så sök, sök, sök
#Ändra hur mycket du vill det här är bara ideer jag hade

#Tror att kruxet verkligen ligger i att lista ut hur meddelande ska gå runt sen så blir det ganska simpelt

#Det är väldigt råligt att blanda engelska och svenska

##################################################################################################################################
# Variabel deklarationer                                                                                                         #
##################################################################################################################################
#En Enum för att märka olika typer av meddelande. du använder den så här verkar det som messageType.WANTED eller vilken du nu vill använda
class processStates(Enum):
    WANTED = 0
    HELD = 1
    RELEASED = 2

#Tror inte vi behöver den här heller
#class msgTypes(Enum):
#    REQUEST = 0
#    REPLY = 1

#Kolla upp hur namedtuples, fungerar ungefär som en struct i c.
#Hade ideen för dessa när vi började så vet inte om de blir så bra
mutexState      =   namedtuple('State', 'state priority replylst')
mutexPriority   =   namedtuple('Priority', 'timestamp pid')
mutexMessage    =   namedtuple('Message', 'msgtype mutexName priority')

#Använda denna för att se
processInfo =    { }

#Använd inte den här tror jag använd message queue istället
#mutexQueue =   {
#                    'proc_a': statetable['proc_a'],
#                    'proc_b': statetable['proc_b'],
#                    'proc_c': statetable['proc_c']
#                }

messageQueue = {}
messageListener = None

remotes_n = 2
prio = None

#Kan eventuellt använda denna för att när vi vill skicka meddelande
processAddress = {'proc_a': ('192.168.0.50', '8000'), 'proc_b': ('192.168.0.50', '8001'), 'proc_c': ('192.168.0.50', '8002')}

##################################################################################################################################
#Auxillary funktioner                                                                                                            #
##################################################################################################################################
#Kallar på denna först för att skicka request messages till alla andra processer och lite annat eventuellt.
def MutexInit(IP, procPort, procPid, procName):
    processInfo['processName'] = procName
    processInfo['processPID'] = procPID
    processInfo['processState'] = processStates.RELEASED

    prio = mutexPriority(timestamp = datetime.now, pid = procpid)
    StateTable[procname] = mutexState(
                                        state    =  mutexStates.RELEASED,
                                        priority =  mutexPriority(timestamp = datetime.now, pid = procpid),
                                        replylst =  remotes_n
                                    )
    #TODO create thread for message listening

def UpdateMutexQueue():
    #TODO update mutex queue on recieving of a message

##################################################################################################################################
# Meddelande funktioner                                                                                                          #
##################################################################################################################################
#Den här tror jag vi kommer behöva för att skicka meddelande till andra processer.
def SendMessage(addr, message):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect(addr)
    s.send(message)
    s.close()

def MessageListener():
    #TODO link function to thread so that it can listen to incoming messages
    #TODO restructure
    #TODO add some kind of conditional when you recieve a message to update the message queue
    #     messageQueue['procName']
    #     messageQueue['procAddr']

    #Tog bara det här från den andra koden för att se hur man gör
    msgThread = threading.Thread(target = messageListener, args = ((client, addr)))


##################################################################################################################################
# Mutex Funktioner                                                                                                               #
##################################################################################################################################

#Do we need this?????????????????
def MutexHeld():
    for n in mutexQueue.items():
        processName, state = n
        if stateTable[processName].state == stateTypes.HELD:
            return True
        return False

def GetMutexLock(mutex);
    processInfo['processState'] = processStates.WANTED
    #meddelande som vi skickar iväg
    message = mutexMessage(msgType = mutex, mutexName = mutex, priority = prio)

    #Tror att multicasten till de andra processerna kommer se ut så här kanske
    for n in processAddress
        processName, processAddr = n            #Splittar tuplen i två delar namnet och addressen till respektive variabel
        if n not in processInfo['processName']: #Egna processen vill vi inte skicka meddelande till
            SendMessage(processAddr, message)

#Uppdatera eget mutexstate och skicka meddelande till alla andra processer state i meddeleandet så att de också kan uppdatera
def ReleaseMutexLock(mutex, pname):
    processInfo['processState'] = processStates.RELEASED

    for n in mutexQueue:


    return True

    if condition:
        return false

#Vette Fan
def MutexExit():