# small chat for a lonely person
# need to debug and some updates to work
# all in single paste
import socket
import asyncio
from datetime import datetime
from os import system
import os

class Socket:
    def __init__(self):
        self.socket = socket.socket(
            socket.AF_INET,
            socket.SOCK_STREAM,
        )  # TCP/IP
        self.main_loop = asyncio.get_event_loop()   # single loop

    async def send_data(self, data):
        raise NotImplementedError()

    async def listen_socket(self, lstn_socket=None):
        raise NotImplementedError()

    async def main(self):
        raise NotImplementedError()   # if no-async

    def start(self):
        self.main_loop.run_until_complete(self.main())


    def set_up(self):
        raise NotImplementedError()
class Server(Socket):
    def __init__(self):
        super(Server, self).__init__()

        self.users = []

    def set_up(self):
        self.socket.bind(("127.0.0.1", 5000))
        self.socket.listen(5)
        self.socket.setblocking(False)  # non-blocking
        print('Server is listening')

    async def send_data(self, data):
        for user in self.users:
           await self.main_loop.sock_sendall(user, data)

    async def listen_socket(self, lstn_socket=None):
        if not lstn_socket:
            return
        while True:
            data = self.main_loop.sock_recv(lstn_socket, 2048)  # bytes
            print(f"User sent {data}")
            await self.send_data(data)

    async def accept_sockets(self):
        while True:
            u_socket, address = await self.main_loop.sock_accept(self.socket)    # connected
            print(f"User <{address[0]}> connected.")

            self.users.append(u_socket)
            self.main_loop.create_task(self.listen_socket(u_socket))

    async def main(self):
        await self.main_loop.create_task(self.accept_sockets())


if __name__ == '__main__':
    server = Server()
    server.set_up()
    server.start()  # main loop

from Socket import Socket
from datetime import datetime

from os import system
import asyncio
import os


class Client(Socket):
    def __init__(self):
        super(Client, self).__init__()
        self.messages = ''

    def set_up(self):
        self.socket.connect(
            ("127.0.0.1", 5000)
        )
        self.socket.setblocking(False)    # non-block

    async def listen_socket(self, lstn_socket=None):    # listening
        while True:
            data = await self.main_loop.sock_recv(self.socket, 2048)    # get
            self.messages += f"{datetime.now()} - {data}\n"

            system("cls")
            print(self.messages)

    async def send_data(self, data=None):
        while True:
            data = await self.main_loop.run_in_executor(None, input, ":::")  # get
            await self.main_loop.sock_sendall(self.socket, data.encode("utf-8"))

    async def main(self):
        await asyncio.gather(
            # all in await
            self.main_loop.create_task(self.listen_socket()),
            self.main_loop.create_task(self.send_data())

        )


if __name__ == '__main__':
    client = Client()
    client.set_up()

    client.start()