import socket
import json
from threading import Thread
from random import randint

data_size = 1024
port = 8080
ip = '0.0.0.0'
listens = 10

def send_message(message, login):
    try:
        for i in Users:
            Users[i].conn.send(json.dumps({"type": "message_chat", "message": message, "login": login}).encode('utf-8'))
    except Exception:
        pass

class User():
    def __init__(self):
        self.__name = ""
        self.__login = ""
        self.__password = ""
        self.conn = None
        self.in_room = False

    def __init__(self, name, login, password):
        self.__name = name
        self.__login = login
        self.__password = password
        self.__isActive = True

    def get_name(self):
        return self.__name

    def get_login(self):
        return self.__login

    def get_password(self):
        return self.__password


class Room():
    def __init__(self, RoomName, RoomPassword, login):
        self.__RoomName = RoomName
        self.__RoomPassword = RoomPassword
        self.__Players = [Users[login]]
        self.__id = randint(0, 9999999)

    def get_id(self):
        return self.__id

    def get_players(self):
        return self.__Players

    def add_players(self, login):
        self.__Players.append(Users[login])

class getting_message(Thread):
    def __init__(self, conn, login):
        Thread.__init__(self)
        self.conn = conn
        self.login = login


    def run(self):
        while True:
            try:
                data = self.conn.recv(data_size)
                print(data)
                data = json.loads(data.decode('utf-8'))
                if data['type'] == 'message_chat':
                    print('here')
                    send_message(data['message'], data['login'])
                if data['type'] == 'create_room':
                    result = CreateRoom(data['login'], data['RoomName'], data['RoomPassword'])
                if data['type'] == 'ConnectToRoom':
                    result = ConnectToRoom(data['login'], data['RoomID'])
                if data['type'] == 'GetPlayersInRoom':
                    result = GetPlayersInRoom(data['RoomID'])
                if not data['TCP']:
                    result['type'] = data['type']
                    self.conn.send(json.dumps(result).encode('utf-8'))
            except json.JSONDecodeError:
                pass

class take_login(Thread):
    def __init__(self, conn):
        Thread.__init__(self)
        self.conn = conn
        self.login = ''

    def run(self):
        while True:
            try:
                data = self.conn.recv(data_size)
                #print(data)
                data = json.loads(data.decode('utf-8'))
                if data['type'] == 'registration':
                    result = registration(data['login'], data['name'], data['password'])
                elif data['type'] == 'authorization':
                    result = authorization(data['login'], data['password'])
                elif data['type'] == 'connection':
                    result = {"status": True}
                else:
                    result = {"status": False, "error": "incorrect requst"}
                result['type'] = data['type']
                self.conn.send(json.dumps(result).encode('utf-8'))
                print(result)
                if result["status"]:
                    self.login = data['login']
                    Users[self.login].conn = self.conn
                    break
            except Exception:
                pass
        gm = getting_message(self.conn, self.login)
        gm.start()




class finding_connections(Thread):
    def __init__(self, sock):
        Thread.__init__(self)
        self.sock = sock

    def run(self):
        while True:
            try:
                conn, addr = sock.accept()
                tl = take_login(conn)
                #print(addr, "here")
                tl.start()
            except Exception:
                pass




Users = dict()

sock = socket.socket()
sock.bind((ip, port))
sock.listen(listens)
fc = finding_connections(sock)
fc.start()

Rooms = dict()

def registration(login, name, password):
    try:
        print(login)
        if login in Users:
            return {"status": False, "error": "Login has already in use"}
        user = User(name, login, password)
        Users[login] = user
        return {"status": True}
    except Exception:
        return {"status": False, "error": "something error"}


def authorization(login, password):
    try:
        if login not in Users:
            return {"status": False, "error": "User not exist"}
        '''if Users[login].get_isActive():
            return json.dumps({"status": False, "error": "Accaunt has already in use"})'''
        if Users[login].get_password() != password:
            return {"status": False, "error": "incorrect password"}
        return {"status": True}
    except:
        return {"status": False, "error": "something error"}

def CreateRoom(login, RoomName, RoomPassword):
    try:
        if login not in Users:
            return {"status": False, "error": "User not exist"}
        room = Room(RoomName, RoomPassword, login)
        Rooms[room.get_id()] = room
        Users[login].in_room = True
        return {"status": True, "RoomID": room.get_id()}
    except:
        return {"status": False, "error": "something error"}

def ConnectToRoom(login, RoomID):
    try:
        print(Rooms)
        if Users[login].in_room:
            return {"status": False, "error": "You are in room!"}
        if RoomID in Rooms:
            Rooms[RoomID].add_players(login)
            Users[login].in_room = True
            return {"status" : True}
        else:
            return {"status": False, "error": "Room with this ID not exist"}
    except Exception:
        return {"status": False, "error": "something error"}

def GetPlayersInRoom(RoomID):
    try:
        d = dict()
        d["status"] = True
        d["players"] = []
        if RoomID in Rooms:
            for i in Rooms[RoomID].get_players():
                d["players"].append(i.get_login())
            return d
        else:
            return {"status": False, "error": "Room with this ID not exist"}
    except Exception:
        return {"status": False, "error": "something error"}