DIRECTORY 
Atom USING [ DottedPairNode, GetPName ],
Commander USING [ CommandProc, Register ],
Convert USING [ CardFromRope ],
IO,
LarkPlay USING [ MergeToneSpecs, PlayString, ToneSpec, ToneSpecRec ],
LarkSmartsMonitorImpl,
MBQueue USING [ QueueClientAction ],
NamesGV USING [ GVGetAttribute ],
Nice,
RefID USING [ ID, Reseal, Unseal ],
RefTab USING [ Create, Fetch, Ref, Store ],
Rope USING [ Concat, ROPE ],
ThNet USING [ pd ],
ThParty USING [ Advance, ConversationInfo, DescribeParty, GetConversationInfo, GetKeyTable, GetPartyInfo, PartyInfo  ],
ThPartyPrivate USING [ GetCurrentParty ],
Thrush USING [
ActionReport, ConvEvent, ConversationID, PartyID, PartyType, NB, notReallyInConv, nullConvID, nullID, Reason, ROPE, SHHH, SmartsID, StateID, StateInConv ],
ThSmartsPrivate USING [
ConvDesc, ConvDescBody, ConvRequest, ConvRequestBody, EnterLarkState, LarkState, OpenConversations, ParseState, SmartsInfo ],
ThSmartsRpcControl,
Triples USING [ Select ],
TU,
VoiceUtils USING [ MakeAtom, ProblemFR, Report, ReportFR ]
;

LarkSmartsSupImpl: CEDAR MONITOR LOCKS root
IMPORTS
Atom,
Commander,
Convert,
IO, 
LarkPlay,
root: LarkSmartsMonitorImpl,
MBQueue,
NamesGV,
Nice,
RefID,
RefTab,
Rope,
ThNet,
ThParty,
ThPartyPrivate,
ThSmartsPrivate,
Triples,
TU,
VoiceUtils

EXPORTS ThSmartsPrivate
SHARES LarkSmartsMonitorImpl = {
OPEN IO;


ConversationID: TYPE = Thrush.ConversationID;
nullConvID: ConversationID=Thrush.nullConvID;
ConvDesc: TYPE = ThSmartsPrivate.ConvDesc;
ConvEvent: TYPE = Thrush.ConvEvent;
Reseal: PROC[r: REF] RETURNS[RefID.ID] = INLINE {RETURN[RefID.Reseal[r]]; };
NB: TYPE = Thrush.NB;
OpenConversations: TYPE = ThSmartsPrivate.OpenConversations;
PartyID: TYPE = Thrush.PartyID;
nullID: RefID.ID = Thrush.nullID;
ROPE: TYPE = Thrush.ROPE;
SmartsID: TYPE = Thrush.SmartsID;
SmartsInfo: TYPE = ThSmartsPrivate.SmartsInfo;
StateInConv: TYPE = Thrush.StateInConv;
LORA: TYPE = LIST OF REF ANY;

PD: TYPE = RECORD [
timeoutNoAction: INTEGER _ 5,
doReports: BOOL_FALSE,
larkRegistry: ROPE _ ".lark",
doNice: BOOL_FALSE
];
pd: REF PD _ NEW[PD_[]];

LarkProgress: PUBLIC ENTRY PROC[
interface: ThSmartsRpcControl.InterfaceRecord,
shh: Thrush.SHHH,
convEvent: Thrush.ConvEvent
] = {
ENABLE UNWIND => NULL; -- 
RestoreInvariant;
convID: ConversationID = convEvent.self.convID;
info: SmartsInfo = GetSmartsInfo[smartsID: convEvent.self.smartsID];
cDesc: ConvDesc;
whatNeedsDoing: WhatNeedsDoing;
IF info=NIL THEN { Report["No info at Progress", NIL]; RETURN; };
cDesc _ GetConv[ info, convID, TRUE ];

IF convEvent.self.partyID = convEvent.other.partyID THEN { -- own state changed
NoteNewState[cDesc, convEvent];
SELECT info.currentConvID FROM
convID, nullConvID => NULL;
ENDCASE => DoRejectCall[cDesc, convEvent];
RETURN;
};
IF convID#info.currentConvID THEN {
Report["Strange progress report", cDesc.info];
ForgetConv[cDesc];
RETURN;
};

whatNeedsDoing _ whatNeedsDoingIf[cDesc.situation.self.state][convEvent.other.state];
SELECT whatNeedsDoing FROM
$noop, $ntiy => NULL; -- No action is needed, or we don't know what one to take.
$imp => ERROR; -- This is supposed to be impossible!
$xrep => Report["Didn't expect state change report", info];
$frgt => ForgetConv[cDesc];
$invl => {
Report["Invalid state transition", info];
[]_ChangeState[cDesc: cDesc, state: $failed,
reason: $error, comment: "System Error: Invalid state transition"];
};
$idle => {
nb2: NB;
reason: Thrush.Reason;
cInfo: ThParty.ConversationInfo;
[nb2, cInfo] _ ThParty.GetConversationInfo[convID: convEvent.self.convID];
reason _ IF nb2 # $success THEN $error ELSE convEvent.reason;
IF nb2 # $success OR (cInfo.numParties-cInfo.numIdle) <= 1 THEN
[]_ChangeState[cDesc, IF reason=$terminating THEN $idle ELSE $failed, reason];
};
$rback => []_ChangeState[cDesc, $ringback]; -- Provide ring-back signal
$actv => []_ChangeState[cDesc, $active]; -- Go active
$reac => NULL; -- 
Will be used to reactivate when somebody else leaves inactive
$deac => NULL; -- 
Will be used to deactivate when everybody else leaves active;
ENDCASE => ERROR;
};

LarkSubstitution: PUBLIC ENTRY PROC[
interface: ThSmartsRpcControl.InterfaceRecord,
shh: Thrush.SHHH,
convEvent: Thrush.ConvEvent,
oldPartyID: Thrush.PartyID,
newPartyID: Thrush.PartyID
] = {
ENABLE UNWIND => NULL; -- 
RestoreInvariant;
info: SmartsInfo = GetSmartsInfo[smartsID: convEvent.self.smartsID];
cDesc: ConvDesc;
IF info=NIL THEN { Report["No info at Substitution", NIL]; RETURN; };
cDesc _ GetConv[ info, convEvent.self.convID, FALSE ];
IF cDesc=NIL THEN RETURN;
NoteNewState[cDesc, convEvent];
};

LarkReportAction: PUBLIC ENTRY PROC[
interface: ThSmartsRpcControl.InterfaceRecord,
shh: Thrush.SHHH,
report: Thrush.ActionReport
] = { shh _ shh; shh _ shh; }; -- a Place to stand.


QdNotification: ENTRY PROC [r: REF] ~ {
ENABLE UNWIND => NULL; --  
RestoreInvariant;
cDesc: ConvDesc = NARROW[r];
{
OPEN now: cDesc.situation.self;
IF now.state # $notified THEN RETURN; -- Nothing to do any more??
[]_ChangeState[cDesc,
IF VoiceUtils.MakeAtom[DBInfo[now.partyID, $autoanswer].value] = $true THEN $active
ELSE $ringing];
};
};


DoAdvance: INTERNAL PROC[convRequest: ThSmartsPrivate.ConvRequest]
RETURNS [nb: NB] = {
cDesc: ConvDesc = convRequest.cDesc;
DO -- for possible stateMismatch loop
OPEN now: cDesc.situation.self, desired: convRequest.desiredSituation.self;
convEvent: Thrush.ConvEvent;
IF now.state=$idle OR now.state = desired.state THEN RETURN;
[nb, convEvent] _ ThParty.Advance[
credentials: now,
state: desired.state,
reason: convRequest.desiredSituation.reason,
comment: convRequest.desiredSituation.comment,
reportToAll: shouldReportToAll[desired.state]
];
SELECT nb FROM
$success => cDesc.info.NoteNewStateP[cDesc, convEvent];
$stateMismatch => {
cDesc.info.NoteNewStateP[cDesc, convEvent];
IF desired.state = $idle THEN LOOP;
};
$noSuchConv => Report["Conv doesn't exist at Advance", cDesc.info];
$partyAlreadyActive => NULL; -- 
Deal with $canActivate here some time
ENDCASE => AssessDamage[nb, cDesc, convEvent];
EXIT; ENDLOOP;
};

DoRejectCall: INTERNAL PROC[cDesc: ConvDesc, convEvent: ConvEvent] = {
[]_ChangeState[cDesc, $idle, $busy];
};

NoteNewState: PUBLIC INTERNAL PROC[cDesc: ConvDesc, convEvent: ConvEvent] ~ {
OPEN now: cDesc.situation.self;
nb: NB;
larkStateData: LORA _NIL;
state: StateInConv _ convEvent.self.state;
previousState: StateInConv = cDesc.situation.self.state;
savedCurrentConvID: ConversationID;
cDesc.situation _ convEvent^;
IF state = previousState THEN RETURN; -- No conceivable value in acting.
IF cDesc.info.currentConvID=nullConvID THEN
cDesc.info.currentConvID _ cDesc.situation.self.convID;
savedCurrentConvID _ cDesc.info.currentConvID; -- ForgetConv might clear it.
SELECT state FROM
$notified => { -- Somebody else did the notifying.  We have to respond.
cDesc.info.requests.QueueClientAction[QdNotification, cDesc];
};
$ringing, $ringback => larkStateData _ LIST[SetupRingTunes[cDesc]];
$idle, $neverWas => {
ForgetConv[cDesc];
};
$active => {
value: ROPE; dbAtom: ATOM;
larkStateData _ LIST[ComputeConnection[cDesc]];
[, dbAtom, value] _ DBInfo[now.partyID, $audiosource];
larkStateData _ CONS[NEW[Atom.DottedPairNode_[$audioSource, VoiceUtils.MakeAtom[value]]], larkStateData]; --[[$audioSource,audioSource],...]
value _ DBInfo[now.partyID, $transmitonly, dbAtom].value;
larkStateData _ CONS[NEW[Atom.DottedPairNode_[$transmitOnly, VoiceUtils.MakeAtom[value]]], larkStateData];
};
ENDCASE;
IF state > Thrush.notReallyInConv AND cDesc.keyTable=NIL THEN {
[nb, cDesc.keyTable] _ ThParty.GetKeyTable[credentials: now];
IF nb # $success THEN cDesc.keyTable_NIL;
};
IF state> Thrush.notReallyInConv AND cDesc.keyTable#cDesc.info.larkInfo.keyTable AND cDesc.keyTable#NIL THEN larkStateData _ CONS[cDesc.keyTable, larkStateData];
IF now.convID = savedCurrentConvID THEN SetLarkState[cDesc, larkStateData];
};

AssessDamage: PUBLIC INTERNAL PROC [nb: NB, cDesc: ConvDesc, convEvent: ConvEvent] ~ {
};

ChangeState: PUBLIC INTERNAL PROC[
cDesc: ConvDesc,
state: StateInConv _ idle,
reason: Thrush.Reason _ NIL, -- $wontSay
comment: ROPE_NIL
] RETURNS [nb: NB] = {
convRequest: ThSmartsPrivate.ConvRequest;
IF cDesc = NIL THEN RETURN;
convRequest _ NEW[ThSmartsPrivate.ConvRequestBody _ [cDesc: cDesc]];
convRequest.desiredSituation.self.state _ state;
convRequest.desiredSituation.reason _ reason;
convRequest.desiredSituation.comment _ comment;
nb _ DoAdvance[convRequest];
};

GetConv: PUBLIC INTERNAL PROC[info: SmartsInfo, convID: ConversationID, createOK: BOOL_FALSE
] RETURNS [ cDesc: ConvDesc_NIL ] = --INLINE-- {
FOR convs: OpenConversations _ info.conversations, convs.rest WHILE convs#NIL DO
IF convs.first.situation.self.convID = convID THEN RETURN[convs.first];
ENDLOOP;
IF ~createOK THEN RETURN;
cDesc _ NEW[ThSmartsPrivate.ConvDescBody_[]];
cDesc.situation.self _ [ convID: convID, smartsID: info.smartsID,
partyID: ThPartyPrivate.GetCurrentParty[smartsID: info.smartsID].partyID ]; -- 
nb check?
cDesc.info _ info;
info.conversations _ CONS[cDesc, info.conversations];
IF pd.doReports THEN
ReportFR["  ** NewConv %t %g\n", info, time[convID], TU.RefAddr[info] ];
};

ForgetConv: PUBLIC INTERNAL PROC[cDesc: ConvDesc] = {
info: SmartsInfo = cDesc.info;
prev: OpenConversations_NIL;
IF cDesc.situation.self.convID = info.currentConvID THEN info.currentConvID _ nullConvID;
FOR convs: OpenConversations _ info.conversations, convs.rest WHILE convs#NIL DO
IF convs.first # cDesc THEN { prev_convs; LOOP; };
IF prev#NIL THEN prev.rest _ convs.rest ELSE info.conversations _ convs.rest;
RETURN;
ENDLOOP;
};

ComputeConnection: PUBLIC INTERNAL PROC[cDesc: ConvDesc]
RETURNS [pInfo: ThParty.PartyInfo _ NIL] = {
nb: NB;
[nb, pInfo] _
ThParty.GetPartyInfo[credentials: cDesc.situation.self, nameReq: $none, allParties: TRUE];
IF nb # $success OR pInfo[0].partyID=0 THEN {
Problem["No conversation info, or incomplete", cDesc.info]; pInfo_NIL; RETURN; }; -- This is really bad!
};

GetSmartsInfo: PUBLIC PROC[smartsID: SmartsID] RETURNS [info: SmartsInfo_NIL] = {
sd: REF _ RefID.Unseal[smartsID];
IF sd#NIL THEN RETURN[NARROW[Triples.Select[$SmartsData, sd, --info--]]];
};

DBInfo: PUBLIC PROC[partyID: Thrush.PartyID, attribute: ATOM_NIL, prevDbAtom: ATOM_NIL]
RETURNS [dbRname: ROPE_NIL, dbAtom: ATOM_NIL, value: ROPE_NIL] = {
nb: NB _ $success;
rName: ROPE;
dbAtom _ prevDbAtom;
IF dbAtom#NIL THEN rName _ Atom.GetPName[dbAtom]
ELSE IF partyID#nullID THEN
[nb, rName] _ ThParty.DescribeParty[partyID: partyID, nameReq: $current];
IF nb # $success OR rName=NIL THEN RETURN;
dbRname _ rName.Concat[pd.larkRegistry];
IF dbAtom=NIL THEN dbAtom _ VoiceUtils.MakeAtom[rName: rName, case: FALSE];
IF attribute#NIL THEN value _ NamesGV.GVGetAttribute[dbRname, attribute, NIL];
};

Problem: PROC[comment: ROPE, info: SmartsInfo] = {
VoiceUtils.ProblemFR[Rope.Concat["LarkSmarts(%g): ", comment], $Smarts, info, TU.RefAddr[info]];
};

Report: PROC[what: ROPE, info: SmartsInfo] = {
IF NOT pd.doReports THEN RETURN;
VoiceUtils.Report[what, $Lark, info.larkInfo];
};

ReportFR: PROC[what: ROPE, info: SmartsInfo, a1, a2, a3: IO.Value_rope[NIL]] = {
IF NOT pd.doReports THEN RETURN;
VoiceUtils.ReportFR[what, $Lark, info.larkInfo, a1, a2, a3];
};

BeNice: PROC[r: REF, d: INT, info: SmartsInfo] = {
IF NOT pd.doNice THEN RETURN;
Nice.BeNice[r, d, $Lark, info.larkInfo];
};

ringTunes: RefTab.Ref_RefTab.Create[59];
ringTone: LarkPlay.ToneSpec _ NIL;
subduedRingTone: LarkPlay.ToneSpec _ NIL;
outsideRingTone: LarkPlay.ToneSpec _ NIL;
outsideRingTune: PUBLIC LarkPlay.ToneSpec _ NIL;
outsideRingTuneRope: ROPE _ "@300;G%>G<%G%>G<%G%>G<%G%>G<%G%>*C";
ringTuneDelay: NAT _ 2400; -- ms. delay between tune starts.

SetupRingTunes: PROC[cDesc: ConvDesc] RETURNS [toneSpec: LarkPlay.ToneSpec] = {
OPEN self: cDesc.situation.self;
partyID: Thrush.PartyID = self.partyID;
dbName: ROPE = DBInfo[partyID].dbRname;
otherPartyID: Thrush.PartyID_nullID;
otherDbName: ROPE;
otherTune: LarkPlay.ToneSpec_NIL;
otherType: Thrush.PartyType;
defaultSpec: LarkPlay.ToneSpec; -- outside or inside ringing

nb: NB;
pInfo: ThParty.PartyInfo;
divisor: NAT _ 1;
rope: ROPE;
now: BasicTime.GMT = BasicTime.Now[];
expiration: BasicTime.GMT _ now;
ringMode: ATOM;
ringDo: ATOM;

[nb, pInfo] _
ThParty.GetPartyInfo[credentials: [convID: self.convID, partyID: partyID], allParties: TRUE, nameReq: $none];
IF pInfo.numParties=2 THEN {
otherPartyID _ pInfo[1].partyID;
otherType _ pInfo[1].type;
otherDbName_ DBInfo[otherPartyID].dbRname;
};
IF ThNet.pd.ringsInvalid THEN MakeDefaultRingTunes[];
SELECT self.state FROM
$ringback => {
toneSpec _ GetRingTune[otherPartyID];
IF toneSpec=NIL THEN RETURN;
toneSpec _ NEW[LarkPlay.ToneSpecRec _ toneSpec^];
toneSpec.volume _ ThNet.pd.tonesVolume+2;
toneSpec.repeatIndefinitely _ TRUE;
RETURN;
};
$ringing => NULL; -- main case continues below
ENDCASE => RETURN; -- what are we doing here anyhow?


defaultSpec _ SELECT otherType FROM $trunk => outsideRingTone, ENDCASE => ringTone;
rope _ NamesGV.GVGetAttribute[dbName, $expiration, NIL];
IF rope#NIL THEN expiration _ BasicTime.FromNSTime[Convert.CardFromRope[rope]];
rope _ NamesGV.GVGetAttribute[dbName,
IF BasicTime.Period[from: now, to: expiration] > 0 THEN $timedringmode ELSE $ringmode, NIL];
ringMode _ IF rope=NIL THEN $r ELSE VoiceUtils.MakeAtom[rName: rope, case: FALSE];
SELECT ringMode FROM -- $o, $s, $r
$o => RETURN[NIL];
$s => RETURN[subduedRingTone];
$r => NULL; -- largest case continues below
ENDCASE => RETURN[defaultSpec]; -- unknown case; act vanilla
rope _ NamesGV.GVGetAttribute[dbName, $dotune, NIL];
ringDo _ IF rope=NIL THEN $standard ELSE VoiceUtils.MakeAtom[rName: rope, case: FALSE];
SELECT ringDo FROM
$false, $standard => RETURN[defaultSpec];
$both => {
SELECT otherType FROM
$individual, $telephone => {
divisor _ 2;
rope _ NamesGV.GVGetAttribute[otherDbName, $dotune, NIL];
ringDo _ IF rope=NIL THEN $standard ELSE VoiceUtils.MakeAtom[rName: rope, case: FALSE];
IF ringDo=$both THEN otherTune _ GetRingTune[otherPartyID];
};
$trunk => otherTune _ outsideRingTune;
ENDCASE;
};
$true, $tune => NULL; -- continue below
ENDCASE => RETURN[defaultSpec];
toneSpec _ GetRingTune[partyID];
IF toneSpec=NIL THEN RETURN[defaultSpec];
IF otherTune#NIL THEN toneSpec _ LarkPlay.MergeToneSpecs[toneSpec, otherTune, divisor, ringTuneDelay];
};

GetRingTune: PROC[party: PartyID] RETURNS [ringTune: LarkPlay.ToneSpec_NIL] = {
nameAtom: ATOM;
name: ROPE;
ringTuneRope: ROPE;
IF party = nullID THEN RETURN;
[name, nameAtom, ringTuneRope] _ DBInfo[party, $ringtune];
IF ringTuneRope=NIL THEN RETURN;
ringTune _ NARROW[ringTunes.Fetch[nameAtom].val];
IF ringTune#NIL AND ringTune.asRope=ringTuneRope THEN RETURN;
ringTune _ LarkPlay.PlayString[music: ringTuneRope, file: FALSE, volume: ThNet.pd.defaultRingVolume];
[]_ringTunes.Store[nameAtom, ringTune]
};

MakeDefaultRingTunes: PROC = {
ringTone _ NEW[LarkPlay.ToneSpecRec _ [
repeatIndefinitely: TRUE, volume: ThNet.pd.defaultRingVolume,
tones: LIST[LIST[ [f1: 440, f2: 480, on: 2000, off: 4000],
			     [f1: 440, f2: 480, on: 2000, off: 4000]]]]]; 
outsideRingTone _ NEW[LarkPlay.ToneSpecRec _ [
repeatIndefinitely: TRUE, volume: ThNet.pd.defaultRingVolume,
tones: LIST[LIST[ [f1: 440, f2: 480, on: 500, off: 500],
			     [f1: 440, f2: 480, on: 500, off: 4500]]]]]; 
subduedRingTone _ NEW[LarkPlay.ToneSpecRec _ [
repeatIndefinitely: FALSE,
volume: ThNet.pd.defaultRingVolume+ThNet.pd.subduedVolumeInterval,
tones: LIST[LIST[[f1: 440, f2: 480, on: 500, off: 0]]]
]]; 
outsideRingTune _
LarkPlay.PlayString[outsideRingTuneRope, FALSE, ThNet.pd.defaultRingVolume];
ThNet.pd.ringsInvalid _ FALSE;
};


larkStateForState: ARRAY StateInConv OF ThSmartsPrivate.LarkState _ [
silence,    idle,  errorTone, dialTone, silence,   silence,   silence,    ringBack, ringing,
silence,        talking,  silence
];

SetLarkState: INTERNAL PROC[cDesc: ConvDesc, data: LORA ] = {
larkState: ThSmartsPrivate.LarkState _ larkStateForState[cDesc.situation.self.state];
SELECT larkState FROM
$talking => {
spec: ThParty.PartyInfo;
FOR dL: LORA  _ data, dL.rest WHILE dL#NIL DO WITH dL.first SELECT FROM
pI: ThParty.PartyInfo => spec _ pI;
ENDCASE; ENDLOOP;
IF spec=NIL THEN ERROR;
IF spec.numParties=2 AND spec[0].socket.host = spec[1].socket.host THEN
larkState _ cDesc.info.larkInfo.larkState; -- don't change
};
$errorTone => larkState _ SELECT cDesc.situation.reason FROM
$busy, $notImportantEnough => $busyTone,
$absent, $noCircuits, $noParticular, $notFound, $error => $errorTone,
ENDCASE => $errorTone;
ENDCASE;
ThSmartsPrivate.EnterLarkState[cDesc.info.larkInfo, larkState, data];
};


shouldReportToAll: ARRAY StateInConv OF BOOL = [
FALSE,   TRUE, FALSE,  FALSE,    FALSE,    FALSE, FALSE,    FALSE,     TRUE,    TRUE,    TRUE,     TRUE ];
   
WhatNeedsDoing: TYPE = ATOM; -- {

whatNeedsDoingIf: ARRAY StateInConv OF ARRAY StateInConv OF WhatNeedsDoing _ [
[ $imp, $frgt, $frgt, $frgt, $frgt,  $frgt, $frgt, $frgt, $frgt, $frgt,   $frgt, $frgt], --neverWas
[ $imp, $noop, $noop, $noop,  $noop,  $noop, $noop, $noop, $noop, $noop,   $noop, $ntiy ], -- idle
[ $imp, $noop, $noop, $noop,  $noop,  $noop, $noop, $noop, $noop, $noop,   $noop, $ntiy ], -- failed
[ $imp, $imp,  $imp,  $imp,   $imp,   $imp,  $imp,  $imp,  $imp,  $imp,    $imp,  $imp ], -- reserved
[ $imp, $imp,  $imp,  $imp,   $imp,   $imp,  $imp,  $imp,  $imp,  $imp,    $imp,  $imp ], -- parsing
[ $imp, $idle,$noop, $invl,  $invl,  $invl, $xrep, $xrep,$rback,$actv,  $actv, $actv ], -- initiating
[ $imp, $idle,$noop, $invl,  $invl,  $invl, $xrep, $noop, $noop, $ntiy,   $noop, $ntiy ], -- notified
[ $imp, $idle,$noop,$invl,   $invl,  $invl, $noop, $xrep, $noop, $ntiy,   $actv, $ntiy ], -- ringback
[ $imp, $idle,$noop, $invl,  $invl,  $invl, $xrep, $xrep, $noop, $ntiy,   $noop, $ntiy ], -- ringing
[ $imp, $idle,$noop, $invl,  $invl,  $invl, $xrep, $xrep, $noop, $ntiy,   $noop, $ntiy ], -- canActivate
[ $imp, $idle,$noop, $invl,  $invl,  $invl, $xrep, $xrep, $noop, $ntiy,   $reac, $deac ], -- active
[ $imp, $idle,$invl, $invl,  $invl,  $invl, $xrep, $xrep, $noop, $ntiy,   $ntiy, $ntiy ] -- inactive (current ^)
];

ViewCmd: Commander.CommandProc = TRUSTED {
Nice.View[pd, "Lark PD"];
};
Commander.Register["VuLarkSmarts", ViewCmd, "Program Management variables for Lark Smarts"];
}.
)ˆLarkSmartsSupImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last modified by D. Swinehart, June 1, 1986 7:49:57 pm PDT
Polle Zellweger (PTZ) August 27, 1985 9:07:50 pm PDT

Definitions
Party-invoked actions

Some party has changed state in a conversation we know about.
Three cases:
Another smarts initiated a state change for this party, and we're not receptive.
(For now, when we don't know about that conversation and already in another)
Another smarts initiated a change for this party, and we're receptive.
(New conversation and we're idle or a conversation we're in already)
Another party changed state in a conversation we know about.
(new conversation and we're idle) or (this is the one we like)
We have to reject this, since we're already dealing with another conv.
We are (still) willing to seriously consider only one conversation at a time.
Situation is that someone else reported a change of theirs concerning a conversation we've expressed no interest in.  I don't believe this should happen.
Someone else's state changed in a conv. we're interested in; see if it means anything to us!
We don't expect reports of state changes like $notified and $ringback to be reported to us unless it's us.
We were told something about a conversation we didn't particularly care to know about.  Forget it.
We don't know a valid interpretation of this transition on someone else's part when we're in the state we're in.
If everybody else is gone, go too.  
I'm sure I've got the dial-tone stuff messed up.
A poacher has substituted for a poachee, or the other way around.  Update state so that if it's us, we know who we are.
No conversation state has changed, so just update our notion of our state and quit.
Queued procedures  via request or party->smarts report
All have prefix "Qd" (queued request)

The only ones left are those that avoid recursive calls on ThParty.Advance and on NoteNewState.  Even those could probably be eliminated with a bit more thought.  Like maybe Loop with the resulting ConvEvent.  

We have been invited to join a conversation, and we were not otherwise occupied.  Decide how to deal with it.  r is the updated cDesc
The only question is whether to ring or to accept right away.
Action procedures: change state, queue up interval request, and so on.
All have prefix "Do"

More comfortable if this were a complete check for reasonable transitions.  For now, if the initial request wasn't a transition to $idle and we got a state mismatch, we've given up, assuming that what our other smarts did was as reasonable as what we wanted to do.  Later queued actions, and later actions in LarkSmartsImpl (synchronous with user actions) will have to detect any anomalies and deal with them.  
We and some other smarts acting on our behalf requested something at the same time.  The other one won.  If we were trying to hang up, we must persist.  Otherwise, assume the winner was right.
Unusual, but possible if idle report took a real long time to get here.
Update procedures: record state changes, take local actions based on what they are, and so on.
All Update procedures have prefix "Note".  These procedures should never result directly in another ThParty request, to avoid uncontrolled recursions.  (It might be necessary for them to queue another -- thinking particularly of the "going idle" case.)

cDesc hasn't been updated with convEvent, yet, so comparisons of previous and current state are possible here if desirable.

This is the only time a change in our own state has to be reacted to? Still queued up because otherwise the state-management is confusing. 

If off-hook or speakerphone on, schedule a new dial-tone?  I'm sure there's not enough info around to know why the other party quit, at this time.
Earliest opportunity to get keys
The test prevents changes in lark state for a conversation that we're participating in but don't have the voice terminal connected to.

nb # $success after a call to ThParty.  It was also not one of the failures that one expects in normal discourse.  Decide how bad it is.
SELECT nb FROM

Connection Management Utilities
Just remove its cDesc from info.conversations; also clear info.currentConvID if it's us.
Socket assignment:  Each transmitting host gets an assigned socket (ThParty makes them) and ThParty.GetConversationInfo returns a list of them (self first).  One transmits voice to a socket comprised of the other host's address combined with one's OWN socket number.  In a conference, the other host is the multicast host.  One listens to some number of sockets, comprised of the other host's (or multicast) address, and their own socket numbers.  This makes the multicast case consistent.
A ConnectionSpec, when sent to the lark, includes:
buffer: {in1, in2, out1, out2, out3}.  A buffer to which analog-to-ethernet (ini, corresponding to txi) or ethernet-to-analog (outj, corresponding to rxj) samples for this connection will be queued.  When running the standard program O3I1 (1 in, 3 out) only in1 can be used, and any ethernet-to-analog connection can be assigned to any of the outj buffers.  This is the conference mode.  When running O2I2 (2 in, 2 out), in1 and out1 are paired, as are in2 and out2; out3 is not used.  This is the "simultaneous back door and front door call" mode.
localSocket: for ini (txi) buffers, this is ignored by the Lark Pup code.  For outj (rxj) buffers, this specifies the socket on which to listen -- see above.
remoteSocket: ignored for outj (rxj) buffers.  For in1 (tx1) buffers, specifies the socket to send to.
This call now simply gets the PartyInfo from ThParty; LarkOutImpl produces the actual connection specs and sends them on to the lark.

Other Utilities
Ring Tune Stuff  but for GFI's, would move to another file.


Doesn't handle conference situations: look for a party in ringing or ringBack state!
We are being called.  Figure out how to respond.
If there's an expiration for a temporary ringing mode, and it hasn't expired yet, use it.  If there isn't one or it has expired, use the permanent ringing mode.

We're ringing.  Figure out how to do it.
This produces a second ring tune, compatible with the callee's; they will be played together.
Returns the ring tune, if any, associated with the party.  If the caller wants to change anything, it must copy the results, since GetRingTune doesn't.
State Transition Tables
neverWas, idle,  failed,    reserved, parsing,  initiating, pending,  maybe,   ringing, 
canActivate,  active,   inActive
If connection is to the back door on the same machine, Trunk smarts has already set state to trunkTalking, or is about to.  Don't change it.
See the discussion of sockets  they'll be equal only when sender and receiver is same host. 
We're disallowing conferences in this case.
Should we report this transition to everyone, or just to our own smartses?
never    idle  error   reserved  parsing   init   notified  ringback   ringing  canAc    active    inactive
Just codes to dispatch on in Supervisor; explained there
$noop, $idle, $actv, $rback, $reac, $deac, $frgt, -- cases explained in code
$invl, -- considered an invalid request
$xrep, -- we got a report we feel we shouldn't have got
$ntiy, -- not implemented yet
$imp --  this situation should not arise even in the face of invalid requests
};
If we're in the state identified by the row, and someone else in the conversation reports a transition onto the state identified by the column, what should we do?

 never idle   failed resrv  pars    init   notif  rback  ring  canAc     activ inact -- _ (other)
(Clip this table to view without these comments.)
This situation arises when we've forgotten about the conversation that somebody else is still reporting on.
The actions of other parties are not of interest to us yet, since they're not in this conv.
Ditto.
They can either enter ringing to indicate interest, or go active without ringing
We don't expect to hear from others while we're deciding whether to play
They have earlier expressed interest noopringing), and are now joining the fray
The only thing that interests us here is everybody else quitting.
Debugging nonsense
Swinehart, May 15, 1985 11:05:22 am PDT
Cedar 6.0, add Prose stuff as direct copy of Interval stuff.
changes to: IntervalSpecs, ProseSpec, ProseSpecs, LarkState, LarkProgress, LarkSupervise, EnqueueProses
Swinehart, May 22, 1985 12:15:11 pm PDT
hotLine => autoAnswer
changes to: LarkSupervise
Swinehart, July 2, 1985 10:09:14 am PDT
Fixing up trunkTalking stuff
changes to: LarkSupervise, LarkStateForState
Polle Zellweger (PTZ) July 11, 1985 6:15:01 pm PDT
changes to: DIRECTORY, EnqueueProses, ReportProseDone, LarkSupervise
Polle Zellweger (PTZ) July 16, 1985 9:42:51 pm PDT
changes to: LarkProgress, LarkSupervise, ReportProseDone
Polle Zellweger (PTZ) July 30, 1985 4:41:39 pm PDT
Handle copying of newProses correctly - give Lark its own copy.
changes to: LarkSupervise
Swinehart, August 6, 1985 2:26:39 pm PDT
Merge PTZ ProseSpec changes
changes to: DIRECTORY, LarkProgress, LarkSupervise, EnqueueProses
Polle Zellweger (PTZ) August 14, 1985 6:12:13 pm PDT
Prose flushing, also fix undesired speakerphone hangup for intervals, proseSpecs.
changes to: LarkProgress, LarkSupervise
Polle Zellweger (PTZ) August 22, 1985 2:04:45 pm PDT
changes to: LarkProgress -- comment out some optimizing queue flushing
Swinehart, October 28, 1985 9:58:08 am PST
Handle => ID, H => Reseal, Log => VoiceUtils
changes to: DIRECTORY, LarkSmartsSupImpl, ConversationID, Reseal, IntervalSpec, NB, nullID, PartyID, SmartsID, LarkProgress, LarkSupervise, GetConv, GetSmartsInfo
Swinehart, November 9, 1985 5:03:39 pm PST
Major revision: MBQueue replaces supervisor process.  More responsibility for own state transitions, socket calculations, key maintenance, ...
changes to: LarkProgress, NoteProgress, LarkSupervise, GetConv, larkStateForState, transForStates, ConvEvent, NoteProgress, RejectCall, NoteNewState, LarkSupervise, whatNeedsDoingIf, pairedState, WhatNeedsDoing, ]

Swinehart, June 1, 1986 7:33:23 pm PDT
Test hypothesis that Smarts supervisory actions don't have to be queued, since progress reports are queued at the Party level.  Will vastly simplify Smartses.  Keep the MBQueue around for things that might take a while and that can be done out of sequence.  In fact, can keep LarkSmartsImpl's use of the MBQueue around for a while.  It's harmless, says here.  Left in also to help with QdNotification, although that's considered eliminatable.
changes to: LarkProgress, LarkSubstitution, QdLarkProgress, QdSubstitution, QdNotification, NoteNewState, LarkReportAction



Κ₯˜š
œ™Icodešœ
Οm
œ1™<Jš
œ:™:K™4J™—šΟk	œ
˜
Jšœžœ˜(Jšœ
žœ˜*Jšœžœ˜Jšžœ
˜Jšœ	žœ7˜EJ˜Jšœžœ˜$J˜!J˜Jšœžœžœ˜#J˜+Jšœžœ˜Jšœžœ˜Jšœžœj˜wJšœžœ˜)Jš	œžœ@žœ/žœžœ#˜ͺ
šœžœ˜Jš
œ}˜}—Jš
œ˜Jšœžœ˜Jš
ž˜Jš
œ:˜:J˜
J˜—šœž
œ
žœ˜+š
ž˜J˜Jš
œ
˜
Jš
œ˜Jšžœ˜J˜	J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜Jš
ž˜J˜
J˜—Jšžœ˜Jšžœ˜ Jšžœ
žœ
˜J˜—™J˜šœžœ˜-Jš
œ-˜-—Jšœ
žœ˜*Jšœžœ˜#JšΟnœžœžœžœžœžœžœ˜LJšžœžœ
žœ
˜Jšœžœ%˜<šœ	žœ˜J˜!—Jšžœžœ
žœ
˜Jšœ
žœ˜!Jšœžœ˜.Jšœ
žœ˜'Jšžœžœžœ
žœ
žœ
žœ
˜J˜šžœžœžœ˜Jšœžœ˜Jšœžœ
žœ
˜Jšœžœ˜Jšœžœ
ž˜J˜—Jš	œžœ
žœžœ
žœ˜J˜—š
œ™J™šŸœžœ
žœ
žœ
˜ J˜.Jšœžœ
˜Jš
œ˜Jš
œ˜Kšžœ
žœžœΟc˜-J™=™™PJ™L—™FJ™D—J™<—Jš
œ/˜/Jš
œD˜DJ˜J˜Jš
žœžœ
žœ!žœžœ˜AJšœžœ˜&J˜šžœ2žœ ˜OKš
œ˜šžœž˜šœžœ
˜Jš
œ>™>—šžœ#˜*Jš
œF™FK™M—Kšžœ
˜K˜——šžœžœ˜#J™™
J˜.Jš
œ˜Jšžœ
˜Jš
œ˜—J˜Jš
œ\™\Kš
œU˜Ušžœž˜Kšœžœ :˜PKšœžœ %˜4š
œ;˜;K™j—˜K™b—š
œ
˜
K™pKš
œ)˜)š
œ,˜,Kš
œC˜C—Kš
œ˜—š
œ
˜
Kš
œV™VKšœžœ
˜K˜Kš
œ ˜ Kš
œJ˜JKš
œ=˜=šžœžœ'ž˜?Kšœžœžœžœ˜N—K˜—Kšœ, ˜GKšœ) ˜5Kšœ	žœ B˜QKšœ	žœ @œ
 
˜QKšžœžœ
˜—J˜J˜—šŸœžœ
žœ
žœ
˜$J˜.Jšœžœ
˜Jš
œ˜J˜J˜Jš
œ˜Kšžœ
žœžœ ˜-J™wK™SJš
œD˜DJ˜Jš
žœžœ
žœ%žœžœ˜EJšœ.žœ˜6Jšžœžœ
žœ
žœ
˜J˜J˜J˜—šŸœžœ
˜$J˜.Jšœžœ
˜Jš
œ˜Jšœ ˜3—˜J˜——šœ %™7J™%JšΟt
œ‘
‘2™Τ
J™šŸœžœ
žœžœ˜'K™…
Kšžœ
žœžœ ˜.Kšœžœ˜˜
Kšžœ˜K™=Kšžœžœ
žœ ˜Aš
œ˜šžœEžœ˜SKšžœ˜——K˜—K˜J˜——™FJ™J˜šŸ	œžœ
žœ*˜BKšžœžœ˜K˜$Kšžœ
 "˜%KšžœG˜KK˜šžœžœžœ
žœ
˜<K™—š
œ"˜"Kš
œ˜Kš
œ˜Kš
œ,˜,Kš
œ.˜.Kš
œ-˜-Kš
œ˜—šžœž˜K˜7˜K™ΐ
K˜+Kšžœžœ
žœ
˜#K˜—š
œC˜CKš
œG™G—Kšœžœ *˜GKšžœ'˜.—Kšžœžœ
˜K˜K˜—šŸœžœ
žœ+˜FK˜$Kš
œ˜K˜——™^J™ό
J™šŸœžœ
žœ+˜MKšžœ˜Kšœžœ
˜Kšœžœ
žœ
˜K˜*K˜8K˜#K™{K˜Kšžœžœ
žœ "˜Hšžœ%ž˜+K˜7—Kšœ/ ˜Lšžœž˜šœ 8˜GK™
Kš
œ=˜=K˜—Kšœ'žœ˜C˜K™”
K˜K˜—š
œ˜Kšœžœ
žœ
˜Kšœžœ˜/Kš
œ6˜6Kšœžœ
žœR "˜Œ
Kš
œ9˜9Kšœžœ
žœR˜jK˜—Kšžœ
˜—šžœ žœžœ
žœ˜?Kš
œ ™ Kš
œ=˜=Kšžœžœžœ
˜)K˜—Kšžœžœ-žœžœ
žœžœ ˜‘
šžœ žœ$˜KK™†
—K˜K˜—šŸœžœ
žœžœ,˜VK™‰
K™K˜—J™—™J˜šŸœžœ
žœ
žœ
˜"J˜J˜Jšœžœ ˜(Jšœ	žœ
ž˜Jšœžœžœ˜Jš
œ)˜)Jšžœ	žœ
žœ
žœ
˜Jšœžœ3˜DJ˜0J˜-J˜/J˜J˜J˜—šŸœžœ
žœ5ž
˜\Jšœžœžœ 
œ˜0šžœ;žœžœ
ž˜PJšžœ,žœ
žœ˜GJšžœ
˜—Jšžœžœ
žœ
˜Jšœžœ"˜-š
œA˜AJšœL 
œ
˜Z—J˜Jšœžœ˜5šžœž˜Jš
œH˜H—J˜J˜—šŸ
œžœ
žœ˜5J™XJ˜Jšœžœ
˜Jšžœ2žœ!˜Yšžœ;žœžœ
ž˜PJšžœžœžœ˜2Jšžœžœ
žœžœ!˜MJšžœ
˜Jšžœ
˜—J˜J˜—šŸœžœ
žœ˜8Jšžœžœ˜,J™ι™2JšœOΟd
œ’
œ’
œ’
œΑ
’
œΙ
™€Jš	œ’
œ’
œ9’
œ’
œE™
Jšœ’
œ’
œC™f—J™…
Jšœžœ
˜š
œ
˜
JšœTžœ˜Z—šžœžœžœ˜-JšœBžœžœ ˜h—J˜—J™—™J˜š
Ÿ
œžœ
žœžœžœ˜QJšœžœ˜!Jšžœžœ
žœ
žœ
žœ! œ˜IJš
œ˜J˜—šŸœžœ
žœ%žœ
žœžœ
žœ
˜WJšžœžœ
žœ
žœ	žœ
žœ˜BJšœžœ˜Jšœžœ
˜Jš
œ˜Jšžœžœ
žœ˜0šžœ
žœž˜Jš
œI˜I—Jš
žœžœžœ
žœ
žœ
˜*Jš
œ(˜(Jšžœžœ
žœ2žœ˜KJšžœžœ
žœ4žœ˜NJš
œ˜—J˜šŸœžœ
žœ˜2JšœNžœ˜`J˜J˜—šŸœžœžœ˜.Jšžœ
žœžœ
žœ
˜ Jš
œ.˜.J˜—J˜šŸœžœžœ žœ˜PJšžœ
žœžœ
žœ
˜ Jš
œ<˜<J˜—J˜šŸœžœžœžœ˜2Jšžœ
žœžœ
žœ
˜Jš
œ(˜(J˜J˜——™<J™J˜(Jšœžœ
˜"Jšœ%žœ
˜)Jšœ%žœ
˜)Jšœžœžœ
˜0Jšœžœ(˜AJšœžœ	 !˜<J˜šŸœžœžœ"˜OJšžœ˜ J˜'Jšœžœ˜'J˜$Jšœ
žœ
˜Jšœžœ
˜!J˜Jšœ  ˜<J˜Jšœžœ
˜J˜Jšœ	žœ˜Jšœžœ
˜Jšœžœ˜%J˜ Jšœ
žœ
˜Jšœžœ
˜
J˜š
œ
˜
JšœWžœ˜m—šžœžœ˜J™VJš
œ ˜ J˜Jš
œ*˜*J˜—Jšžœžœ˜5šžœž˜˜J˜%Jšžœ
žœ
žœ
žœ
˜Jšœžœ#˜1J˜)Jšœžœ
˜#Jšžœ
˜J˜—Jšœžœ ˜.šžœžœ !˜4J˜——J™0J™ 
J˜Jšœžœžœžœ˜SJšœ3žœ˜8Jšžœžœ
žœ?˜O˜%Jšžœ1žœžœžœ˜\—Jšœžœžœ
žœžœ(žœ˜Ršžœ
žœ
 
˜"Jšœžœ
žœ˜Jšœžœ˜Jšœžœ ˜+Jšžœžœ ˜<—J™J™(Jšœ/žœ˜4Jšœ	žœžœ
žœžœ(žœ˜W˜Jšœžœ˜)˜
šžœž˜˜Jš
œ˜Jšœ4žœ˜9Jšœ	žœžœ
žœžœ(žœ˜WJšžœžœ'˜;J™]J˜—Jš
œ&˜&Jšžœ
˜—J˜—Jšœžœ ˜'Jšžœžœ˜—J˜ Jšžœ
žœ
žœ
žœ˜)Jšžœžœ
žœQ˜fJš
œ˜J˜—šŸœžœžœžœ˜OJ™—
Jšœ
žœ
˜Jšœžœ
˜Jšœžœ
˜Jšžœžœ
žœ
˜J˜:Jšžœžœ
žœ
žœ
˜ Jšœžœ ˜1Jš
žœ
žœ
žœžœ
žœ
˜=Jšœ:žœ&˜eJ˜&˜J˜——šŸœžœ˜šœžœ˜'Jšœžœ%˜=šœžœ
žœ*˜:Jš
œ5˜5——šœžœ˜.Jšœžœ%˜=šœžœ
žœ(˜8Jš
œ4˜4——šœžœ˜.Jšœžœ
˜Jš
œB˜BJšœžœ
žœ&˜6Jš
œ˜—š
œ˜Jšœ)žœ˜L—Jšœžœ
˜J˜J˜——™J˜˜EJ™XJ˜\J™ J˜!J˜J˜—šŸœžœ
žœžœ˜=Jš
œU˜Ušžœž˜š
œ
˜
J™Œ
Jš
œ˜šžœžœžœžœ
žœ
žœ
žœ
ž˜GJš
œ#˜#Jšžœžœ
˜—Jšžœžœ
žœ
žœ
˜šžœžœ+ž˜GJ™Š
Jšœ+ ˜:—J˜—šœžœ 
ž˜<Jš
œ(˜(Jš
œE˜EJšžœ˜—Jšžœ
˜—J˜EJ˜—J˜J™JJ˜šœžœ
žœ
žœ˜0Jš
Πfsk™kš
£j˜jJš
œ˜——šœžœžœ ˜!J™8Jšœ2 ™LJšœ  ™'Jšœ 0™7Jšœ ™Jšœ H™MJ™J˜—š	œžœ
žœ
žœ
žœ˜NJ™’
J™——JšΟf
£`™aš£YΡcfs
˜cJš
œ1™1Jš
œk™k—Jš£[₯˜bJš£[₯	˜dš£Z₯˜eJš
œ[™[—š£Z₯
˜dJš
œ™—š£Ρbfs£,¦£
¦£¦£¦£₯
˜eJ™P—š£¦£M₯˜eJ™H—š£¦£<¦£₯˜eJ™O—š£¦£M₯
˜dJ™A—Jš£¦£M₯˜hJš£¦£=¦£¦£₯	˜cJš£¦£L₯˜pJ˜J˜™šœ!žœ˜*J˜Jš
œ˜—Jš
œ\˜\—J˜™'K™<KšœΟr[™g—™'K™Kšœ§
™—™'K™Kšœ§ ™,—™2Kšœ§8™D—™2Kšœ§,™8—™2K™?Kšœ§
™—™(K™Kšœ§5™A—™4K™QKšœ§™'—™4Kšœ§:™F—™*K™,Kšœ§–
™’
—™*K™Ž
Kšœ§Ι
™Υ
—K™™&K™ΊKšœ§n™z—K™K™K™—…—Fψ†%