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

data_size = 1024
port = 8080
ip = '127.0.0.1'
listens = 10
app = Flask(__name__)

def send_message(message, RoomId):
    print(Rooms)
    room = Rooms[int(RoomId)]
    print(message)
    for i in room.get_players():
        print('send here')
        i.conn.send(json.dumps({"message": message}).encode('utf-8'))

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

    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 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':
                    send_message(data['message'], data['RoomID'])
            except 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'))['login']
                if data in Users:
                    print('here')
                    self.login = data
                    Users[data].conn = self.conn
                    break
            except JSONDecodeError:
                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:
            conn, addr = sock.accept()
            tl = take_login(conn)
            #print(addr, "here")
            tl.start()


Users = dict()

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






class Room(Thread):
    def __init__(self, RoomName, RoomPassword, login):
        Thread.__init__(self)
        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])

    def run(self):
        conn, addr = sock.accept()

        while True:
            try:
                data = conn.recv(1024)
                conn.send(data + "hui".encode('utf-8'))
            except Exception as inst:
                pass

Rooms = dict()

@app.route('/registration', methods=['GET'])
def registration():
    login = request.values['login']
    name = request.values.get('name')
    password = request.values.get('password')
    print(login)
    if login in Users:
        return json.dumps({"status": False, "error": "Login has already in use"})
    user = User(name, login, password)
    Users[login] = user
    return json.dumps({"status": True})



@app.route('/authorization', methods=['GET'])
def authorization():
    login = request.values['login']
    password = request.values['password']
    if login not in Users:
        return json.dumps({"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 json.dumps({"status": False, "error": "incorrect password"})
    return json.dumps({"status": True})

@app.route('/CreateRoom', methods=['GET'])
def CreateRoom():
    login = request.values['login']
    RoomName = request.values['RoomName']
    RoomPassword = request.values['password']
    room = Room(RoomName, RoomPassword, login);
    Rooms[room.get_id()] = room
    room.start()
    return json.dumps({"status": True, "RoomID": room.get_id()})

@app.route('/ConnectToRoom', methods=['GET'])
def ConnectToRoom():
    login = request.values['login']
    RoomID = int(request.values['RoomID'])
    print(Rooms)
    Rooms[RoomID].add_players(login)
    return json.dumps({"status" : True})

@app.route('/GetPlayersInRoom', methods=['GET'])
def GetPlayersInRoom():
    RoomID = int(request.values['RoomID'])
    d = dict()
    d["status"] = True
    d["players"] = []
    for i in Rooms[RoomID].get_players():
        d["players"].append(i.get_login())
    return json.dumps(d)


if __name__ == '__main__':
    app.run(host=ip, port=port)