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

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

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

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'])
            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:
            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 + 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():
    try:
        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})
    except Exception:
        return json.dumps({"status": False, "error": "something error"})



@app.route('/authorization', methods=['GET'])
def authorization():
    try:
        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})
    except:
        return json.dumps({"status": False, "error": "something error"})

@app.route('/CreateRoom', methods=['GET'])
def CreateRoom():
    try:
        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()})
    except:
        return json.dumps({"status": False, "error": "something error"})

@app.route('/ConnectToRoom', methods=['GET'])
def ConnectToRoom():
    try:
        login = request.values['login']
        RoomID = int(request.values['RoomID'])
        print(Rooms)
        if RoomID in Rooms:
            Rooms[RoomID].add_players(login)
            return json.dumps({"status" : True})
        else:
            return json.dumps({"status": False, "error": "Room with this ID not exist"})
    except Exception:
        return json.dumps({"status": False, "error": "something error"})

@app.route('/GetPlayersInRoom', methods=['GET'])
def GetPlayersInRoom():
    try:
        RoomID = int(request.values['RoomID'])
        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 json.dumps(d)
        else:
            return json.dumps({"status": False, "error": "Room with this ID not exist"})
    except Exception:
        return json.dumps({"status": False, "error": "something error"})


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