QsoInProgress.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DigiRite
{
    // QsoInProgress
    // Class that represents an attempt to work another station. It has:
    //  a reference to the sequencer that decides what message should be sent based on our state and messages received
    //  every message received as part of this QSO.
    public class QsoInProgress
    {
        private class QsoInProgressKey
        {
            public QsoInProgressKey(string baseCall, short band)
            {
                this.band = band;
                this.baseCall = baseCall;
            }
            public override int GetHashCode()
            {   // 
                const int bandHashWidth = 32 - 1; // hash with 32 bands
                return (band & bandHashWidth) | (baseCall.GetHashCode() & ~bandHashWidth);
            }
            public override bool Equals(object obj)
            {
                return Equals(obj as QsoInProgressKey);
            }

            public bool Equals(QsoInProgressKey obj)
            {
                return obj != null && obj.band == band && obj.baseCall == baseCall;
            }
            private short band;
            private string baseCall;
        }

        private RecentMessage originatingMessage;
        private int ackMessage;
        private IQsoSequencer qsoSequencer=null;
        private bool messagedThisCycle = true; // when created, we're not starved
        private bool messagedLastCycle = false;
        private bool holdingForAnotherQso = false;
        private bool active=true;
        private bool timedMyselfOut = false;
        private short band = 0;
        private DateTime timeOfLastReceived;
        private bool markedAsLogged = false;
        private uint transmitFrequency = 0;
        private List<XDpack77.Pack77Message.ReceivedMessage> messages = new List<XDpack77.Pack77Message.ReceivedMessage>();
        private const int MAX_CYCLES_WITHOUT_ANSWER = 4;

        public enum ChangeReason { RECEIVE_CYCLE_END, TRANSMIT_CYCLE_END, MESSAGE_RECEIVED, ACTIVE_CHANGED, OTHER };
        public delegate void OnChanged(ChangeReason cr);
        public OnChanged OnChangedCb { get; set; }
        public QsoInProgress(RecentMessage rm, short band)
        {            
            this.band = band;
            originatingMessage = rm;
            messages.Add(rm.Message);      
            this.AckMessage = Properties.Settings.Default.DefaultAcknowlegement;
            timeOfLastReceived = DateTime.UtcNow;
        }

        public bool TransmitedLastOpportunity { get; set; }  = false;

        public XDpack77.Pack77Message.ReceivedMessage Message { get { return messages.First(); } }
        
        public String HisCall {
            get { 
                return ((XDpack77.Pack77Message.ToFromCall)(Message.Pack77Message)).FromCall;
            }
        }

        public int AckMessage { // FT8 supports 3 acknowledgement messages
            set { ackMessage = value; // RRR 73 RR73
                if (ackMessage < 0)
                    ackMessage = 0;
                if (ackMessage >= MainForm.DefaultAcknowledgements.Length)
                    ackMessage = 0;
                }
            get { return ackMessage; }
        }

        public bool InLoggedInactiveState = false;

        public override String ToString()
        {
            XDpack77.Pack77Message.ToFromCall ft = (XDpack77.Pack77Message.ToFromCall)Message.Pack77Message;
            String seq = "";
            if (null != qsoSequencer)
            {
                if (qsoSequencer.IsFinished)
                    seq = "L";
                else
                {
                    if (holdingForAnotherQso)
                        seq = "H";
                    else
                        seq = qsoSequencer.DisplayState;
                }
            }
            if (markedAsLogged)
                seq = "L";
            else if (AmTimedOut)
                seq = "T";
            return String.Format("{0,1} {1,6} {2,4} {3:####;;}", seq, ft.FromCall, Message.Hz, TransmitFrequency);
        }        

        public IQsoSequencer Sequencer { get { return qsoSequencer; } set { qsoSequencer = value; } }

        public uint SentSerialNumber { get; set; } = 0;

        public String SentGrid { get; set; }

        public bool IsLogged {
            get {
                if ((null != qsoSequencer) && qsoSequencer.IsFinished)
                    return true;
                return markedAsLogged;
            }
        }

        private int cyclesSinceMessaged;
        public int CyclesSinceMessaged { get { return messagedThisCycle ? 0 : cyclesSinceMessaged; } }
        public int CyclesSinceMessagedNotHolding { get; private set; } = 0;
        public int CyclesSinceMessagedToMe { get; private set; } = 0;

        public bool CanAcceptAckNotToMe { get; private set; } = true;

        private bool MessagedThisCycle { get { 
                return messagedThisCycle || holdingForAnotherQso; 
                } }

        public DateTime TimeOfLastReceived { get { return timeOfLastReceived; } }

        public bool Active { get { return active; } set { 
                if (value && !active)
                {   // changing from inactive to active
                    CyclesSinceMessagedNotHolding = 0;
                    holdingForAnotherQso = false;
                }
                bool changed = active != value;
                active = value;
                if (changed) OnChangedCb?.Invoke(ChangeReason.ACTIVE_CHANGED);
                } }
        public bool Dupe { get => originatingMessage.Dupe;  }
        public bool Mult { get => originatingMessage.Mult;  }
        public bool MarkedAsLogged { get => markedAsLogged; set { 
                markedAsLogged = value;
                OnChangedCb?.Invoke(ChangeReason.OTHER);
            }
        }
        public uint TransmitFrequency { get => transmitFrequency; 
            set { transmitFrequency = value; 
                holdingForAnotherQso = false;
                OnChangedCb?.Invoke(ChangeReason.OTHER);
            }
        }
        public bool OnHold 
            { get { return holdingForAnotherQso; } }

        public void OnSentAlternativeMessage()
        {
            CyclesSinceMessagedNotHolding = 0;
            messagedThisCycle = true;
        }

        private bool AmTimedOut { get { return !messagedThisCycle && 
                    CyclesSinceMessagedNotHolding >= MAX_CYCLES_WITHOUT_ANSWER; } }

        public bool OnCycleBegin(bool wasReceiveCycle)
        {
            bool ret = messagedThisCycle;
            if (ret)
            {
                CyclesSinceMessagedNotHolding = 0;
                cyclesSinceMessaged = 0;
            }
            else if (wasReceiveCycle)
            {
                cyclesSinceMessaged += 1;
                CyclesSinceMessagedToMe += 1;
            }
            else if (!messagedLastCycle)
            {
                if (!holdingForAnotherQso)
                    CyclesSinceMessagedNotHolding += 1;
            }
            if (AmTimedOut)
            {
                CanAcceptAckNotToMe = false;
                if (active)
                {
                    timedMyselfOut = true;
                    active = false;
                }
            }
            else
                timedMyselfOut = false;
            if (wasReceiveCycle)
            {
                messagedLastCycle = messagedThisCycle;
                OnChangedCb?.Invoke(ChangeReason.RECEIVE_CYCLE_END);
            }
            else
                OnChangedCb?.Invoke(ChangeReason.TRANSMIT_CYCLE_END);
            messagedThisCycle = false;
            return ret;
        }

        static private String toBaseCall(string call)
        {
            string toBaseCall = null;
            if (XDft.Generator.checkCall(call, ref toBaseCall))
                return toBaseCall;
            else
                return call;
        }

        public object GetKey()
        { return GetKey(Message, band);  }

        public static object GetKey(XDpack77.Pack77Message.ReceivedMessage rm, short band)
        {   // separate QsoInProgress for each BaseCall on each band
            XDpack77.Pack77Message.ToFromCall newcall = rm.Pack77Message as XDpack77.Pack77Message.ToFromCall;
            if ((null != newcall) && !String.IsNullOrEmpty(newcall.FromCall))
                return new QsoInProgressKey(toBaseCall(newcall.FromCall), band);
            return null;
        }

        // if the message is to our same CALL...
        public bool AddMessageOnMatch(XDpack77.Pack77Message.ReceivedMessage rm, 
            bool directlyToMe, CallQsled callQsled)
        {
            if (null == qsoSequencer)
                return false;
            try
            {
                if (directlyToMe)
                {
                    CanAcceptAckNotToMe = true;
                    CyclesSinceMessagedToMe = 0;
                }
                else if (callQsled == CallQsled.IsMe)
                {
                    CyclesSinceMessagedToMe = 0;
                }
                else
                {
                    if (!messagedThisCycle)
                    {
                        if (callQsled == CallQsled.None)
                        {
                            // if he sends multiple messages in the same cycle...
                            // ...then we need to "hold" only if this is the only one
                            if (!messagedThisCycle && !markedAsLogged)
                            {
                                // he sent to someone else
                                int freqDif = (int)transmitFrequency;
                                freqDif -= (int)Message.Hz;
                                if (freqDif < 0)
                                    freqDif = -freqDif;
                                if (freqDif <= 60)
                                    holdingForAnotherQso = true;
                            }
                        }
                        else
                        {
                            holdingForAnotherQso = false;
                            if (messagedLastCycle && !IsLogged)
                                return true;
                        }
                    }
                    return false;
                }
                holdingForAnotherQso = false;
                if (timedMyselfOut && !active)
                    active = true;
                messagedThisCycle = true;
                messages.Add(rm);
                timeOfLastReceived = DateTime.UtcNow;
                return true;
            }
            finally
            {
                OnChangedCb?.Invoke(ChangeReason.MESSAGE_RECEIVED);
            }
        }

        public List<XDpack77.Pack77Message.ReceivedMessage> MessageList { get { return messages; } }
    }

}