sdis1819-t7g02

package channels;

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.InetAddress;

import java.net.MulticastSocket;

import java.util.Random;

import service.Cloud;

import service.Constants;

abstract class Channel extends Thread {

        protected MulticastSocket socket;

        protected InetAddress address;

        protected int port;

        protected DatagramPacket rcv;

        protected DatagramPacket send;

        protected int serverId;

        protected Cloud father;

        protected Channel(String addr, String p, int sId, Cloud f) throws IOException {

                address = InetAddress.getByName(addr);

                port = Integer.parseInt(p);

                socket = new MulticastSocket(port);

                serverId = sId;

                father = f; 

        }

        protected MulticastSocket getSocket() {

                return socket;

        }

        protected void setSocket(MulticastSocket socket) {

                this.socket = socket;

        }

        protected InetAddress getAddress() {

                return address;

        }

        protected void setAddress(InetAddress address) {

                this.address = address;

        }

        protected int getPort() {

                return port;

        }

        protected void setPort(int port) {

                this.port = port;

        }

        protected int getServerId() {

                return serverId;

        }

        protected void resetMyPacket(byte[] data) {

                rcv = new DatagramPacket(data, Constants.MAX_MESSAGE_SIZE);

        }

        public void waitRandomTime() throws InterruptedException {

                Random r = new Random();

                int low = 1;

                int high = 401;

                int result = r.nextInt(high-low) + low;

                Thread.sleep(result);

        }

        protected Message captureData() throws IOException {

                byte[] data = new byte[Constants.MAX_MESSAGE_SIZE];

                Message m;

                resetMyPacket(data);

                socket.receive(rcv);

                byte[] filtredData = new byte[Constants.MAX_MESSAGE_SIZE];

                System.arraycopy(rcv.getData(), rcv.getOffset(), filtredData, 0, rcv.getLength());

                try {

                        m = new Message(filtredData, rcv.getLength());

                } catch(IllegalArgumentException e) {

                        System.out.println("Error receiving message: " + e.getMessage());

                        return null;

                }

                return m;

        }

        public synchronized boolean sendMessage(Message m) {

                send = new DatagramPacket(m.toBytes(), m.toBytes().length, address, port);

                try {

                        socket.send(send);

            }

                catch (IOException e) {

                        return false;

            }

            return true;

        }

        public synchronized boolean sendHeader(MessageHeader h) {

                send = new DatagramPacket(h.headerToBytes(), h.headerToBytes().length, father.controlRoom.address, father.controlRoom.port);

                try {

                        socket.send(send);

            }

                catch (IOException e) {

                        return false;

            }

            return true;

        }

        protected void joinChannelGroup() throws IOException {

                socket.joinGroup(address);

        }

        protected void leaveGroupChannel() throws IOException {

                socket.leaveGroup(address);

        }

}