import socket
import time
from threading import Thread, Lock
from copy import deepcopy
import queue
from flask import *
import json
import random
from User import User
from Room import Room

ip = "0.0.0.0"
port = 8108
cnt_listeners = 100
cards_global = [i for i in range(11, 19)] + [i for i in range(21, 29)] \
               + [i for i in range(31, 39)] + [i for i in range(41, 49)]


class Gaming(Thread):
    def __init__(self, room):
        Thread.__init__(self)
        self.room = room
        self.position = 1
        self.cards = deepcopy(cards_global)
        self.extra_cards = []

    def get_cards(self, count):
        cards = []
        for i in range(count):
            print("self.cards", self.cards)
            x = random.randint(0, len(self.cards) - 1)
            print("x", x)
            item = self.cards[x]
            del self.cards[x]
            cards.append(item)
            print("cards", cards)
        cards.sort()
        return cards

    def run(self):
        while True:
            if self.position == 1:
                players_cards = [self.get_cards(10) for i in range(3)]
                extra_cards = self.get_cards(2)
                self.extra_cards = extra_cards
                for i in range(3):
                    login = self.room.users[i].login
                    data = {
                        "type": "cards",
                        "cards": players_cards[i]
                    }
                    messages.put((json.dumps(data).encode('utf-8'), login_connections[login]))
                self.position = 2


class SendingMessage(Thread):
    def __init__(self):
        Thread.__init__(self)

    def run(self):
        while True:
            time.sleep(1)
            print("sm")
            print(messages)
            message, address = messages.get()
            print(message, address)
            address.send(message)


class GettingMessage(Thread):
    def __init__(self, connection):
        Thread.__init__(self)
        self.connection = connection
        self.login = ''

    def run(self):
        while True:
            try:
                data = self.connection.recv(1024)
                print(data)
                data = data.decode('utf-8')
                data = json.loads(data)
                print(data)
                if data['type'] == 'connection':
                    login_connections[data['login']] = self.connection
                    print(login_connections)
                    self.login = data['login']
            except ConnectionResetError:
                connections.remove(self.connection)
                login_connections.pop(self.login)
                break
            print(data)
            if not data:
                print('disconnected')
                break


class FindingConnection(Thread):
    def __init__(self):
        Thread.__init__(self)

    def run(self):
        while True:
            try:
                print("fd")
                connection, address = sock.accept()
                print(connection, address)
                with lock:
                    connections.append(connection)
                    gm = GettingMessage(connection)
                    getting.append(gm)
                    gm.start()
            except socket.error:
                print('something wrong')


app = Flask(__name__)
login_connections = dict()
rooms = []
users = []
sock = socket.socket()
sock.bind((ip, port + 1))
sock.listen(cnt_listeners)
messages = queue.Queue()
connections = []
lock = Lock()

fc = FindingConnection()
fc.start()
sm = SendingMessage()
sm.start()
getting = []
gaming = []


@app.route('/registration', methods=["POST"])
def registration():
    login = request.values['login']
    name = request.values['name']
    password = request.values['password']
    correct_login = True
    for i in users:
        if i.login == login:
            correct_login = False
    if not correct_login:
        return json.dumps({
            "status": False,
            "error": "Такой логин уже используется"
        })
    users.append(User(login, name, password))
    return json.dumps({
        "status": True
    })


@app.route('/authorization', methods=['POST'])
def authorization():
    login = request.values['login']
    password = request.values['password']
    is_correct_data = False
    data = ''
    for i in users:
        if i.login == login:
            is_correct_data = True
            if i.password != password:
                is_correct_data = False
                data = 'Некорректный пароль'
            else:
                data = i.name

    if not is_correct_data and len(data) == 0:
        data = 'Такого логина не существует'
    if not is_correct_data:
        return json.dumps({
            "status": False,
            "error": data
        })
    return json.dumps({
        "status": True,
        "name": data
    })


@app.route('/create_room', methods=["POST"])
def create_room():
    room_name = request.values['room_name']
    password = request.values['password']
    login = request.values['login']
    user = None
    for i in users:
        if i.login == login:
            user = i
    work = True
    room_id = 0
    while work:
        room_id = random.randint(1, 10000)
        work = True in list(map(lambda x: x == room_id, [i.room_id for i in rooms]))
    rooms.append(Room(user, room_name, password, room_id))
    return json.dumps({
        "status": True,
        "room_id": room_id
    })


@app.route('/get_rooms_ids', methods=['GET'])
def get_rooms_ids():
    mas = []
    for i in rooms:
        mas.append(i.room_id)
    return json.dumps({
        "status": True,
        "rooms_ids": mas
    })


@app.route('/has_password', methods=['GET'])
def has_password():
    room_id = request.values['room_id']
    answer = False
    for i in rooms:
        print(i.room_id, room_id, i.room_id == room_id, int(i.room_id) == int(room_id))
        if int(i.room_id) == int(room_id):
            if len(i.password) > 0:
                answer = True
    return json.dumps({
        "status": True,
        "has_password": answer
    })


@app.route('/connect_to_room', methods=['POST'])
def connect_to_room():
    login = request.values['login']
    password = request.values['password']
    room_id = request.values['room_id']
    user = None
    for i in users:
        if i.login == login:
            user = i
    exist = False
    error = ''
    print(rooms)
    for i in rooms:
        print(i.room_id, room_id, int(i.room_id) == int(room_id))
    print(",,,,,,,", room_id)
    for i in rooms:
        if int(i.room_id) == int(room_id):
            if i.password != password:
                error = 'Неверный пароль'
            elif len(i.users) == 3:
                error = 'Эта комната заполнена'
            elif login in [local_user.login for local_user in i.users]:
                error = 'Вы уже состоите в этой комнате'
            else:
                i.users.append(user)
                exist = True

    if not exist and len(error) == 0:
        error = 'Неверный ID'
    if not exist:
        return json.dumps({
            "status": False,
            "error": error
        })
    return json.dumps({
        "status": True
    })


@app.route('/get_rooms', methods=["GET"])
def get_rooms():
    return json.dumps({
        "count": len(rooms),
        "rooms": [i.to_json() for i in rooms]
    })


@app.route('/ready', methods=["GET"])
def ready():
    login = request.values['login']
    for room in rooms:
        print("here1")
        if room.exist(login):
            print("here2")
            room.set_ready(login)
            readies = room.get_readies()
            for i in range(3):
                print("here3")
                if room.users[i].login in login_connections:
                    print("here4")
                    left_name = room.prev_name(room.users[i].login)
                    right_name = room.next_name(room.users[i].login)
                    left_login = room.prev_login(room.users[i].login)
                    right_login = room.next_login(room.users[i].login)
                    print(left_name, right_name, left_login, right_login)
                    data = {
                        "type": "connection_info",
                        "left": {
                            "name": left_name,
                            "is_connect": left_login in readies
                        },
                        "right": {
                            "name": right_name,
                            "is_connect": right_login in readies
                        }
                    }
                    messages.put((json.dumps(data).encode('utf-8'), login_connections[room.users[i].login]))
            if len(readies) == 3:
                g = Gaming(room)
                gaming.append(g)
                g.start()
            return json.dumps({
                "status": True
            })


@app.route('/room_by_login', methods=['GET'])
def room_by_login():
    login = request.values['login']
    room_id = -1
    for room in rooms:
        for user in room.users:
            if user.login == login:
                room_id = room.room_id
    return json.dumps({
        "status": True,
        "room_id": room_id
    })


@app.route('/close', methods=['GET'])
def close():
    fc.join()
    sm.join()
    for i in getting:
        i.join()
    for i in gaming:
        i.join()
    for i in connections:
        i.close()
    sock.close()


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