using System;
using System.Collections.Generic;

namespace RoboidControl {

    /// <summary>
    /// A participant is a device which manages things.
    /// </summary>
    /// It can communicate with other participant to synchronise the state of things.
    /// This class is used to register the things the participant is managing.
    /// It also maintains the communcation information to contact the participant.
    /// It is used as a basis for the local participant, but also as a reference to remote participants.
    public class Participant {
        /// <summary>
        /// Default constructor
        /// </summary>
        public Participant() { }
        /// <summary>
        /// Create a new participant with the given communcation info
        /// </summary>
        /// <param name="ipAddress">The IP address of the participant</param>
        /// <param name="port">The UDP port of the participant</param>
        public Participant(string ipAddress, int port) {
            this.ipAddress = ipAddress;
            this.port = port;
        }

        /// <summary>
        /// The Ip Address of a participant. When the participant is local, this contains 0.0.0.0
        /// </summary>
        public string ipAddress = "0.0.0.0";
        /// <summary>
        /// The port number for UDP communication with the participant. This is 0 for isolated participants.
        /// </summary>
        public int port = 0;

        /// <summary>
        /// The network ID of the participant
        /// </summary>
        public byte networkId;

        /// <summary>
        /// The things managed by this participant
        /// </summary>
        protected readonly List<Thing> things = new List<Thing>();

        /// <summary>
        /// Get a thing with the given ids
        /// </summary>
        /// <param name="networkId">The network ID of the thing</param>
        /// <param name="thingId">The ID of the thing</param>
        /// <returns>The thing when it is found, null in other cases.</returns>
        public Thing Get(byte networkId, byte thingId) {
            Thing thing = things.Find(aThing => aThing.id == thingId);
            //Thing thing = things.Find(aThing => Thing.IsThing(aThing, networkId, thingId));
            // if (thing == null)
            //     Console.WriteLine($"Could not find thing {ipAddress}:{port}[{networkId}/{thingId}]");
            return thing;
        }

        /// <summary>
        /// Add a new thing for this participant
        /// </summary>
        /// <param name="thing">The thing to add</param>
        /// <param name="invokeEvent">Invoke an notification event when the thing has been added</param>
        public void Add(Thing thing, bool checkId = true, bool invokeEvent = true) {
            if (checkId && thing.id == 0) {
                thing.id = (byte)(this.things.Count + 1);
                things.Add(thing);
            }
            // Console.WriteLine($"added thing [{thing.networkId}/{thing.id}]"); 
            Thing foundThing = Get(thing.networkId, thing.id);

            if (foundThing == null) {
                things.Add(thing);

                // if (invokeEvent)
                //     Thing.InvokeNewThing(thing);
                // Console.Write($"Add thing {ipAddress}:{port}[{networkId}/{thing.id}]");
            }
            // else {
            //     if (thing != foundThing) {
            //         // should be: find first non-existing id...
            //         thing.id = (byte)this.things.Count;
            //         things.Add(thing);
            //         // Console.Write($"Add thing, updated thing id to [{thing.networkId}/{thing.id}]");
            //     }
            // }
        }

        /// <summary>
        /// Remove a thing for this participant
        /// </summary>
        /// <param name="thing">The thing to remove</param>
        public void Remove(Thing thing) {
            this.things.Remove(thing);
        }

    }

}