<<>>
    <<RemindUI.mesa>>
    <<Copyright Ó 1990, 1992 by Xerox Corporation.  All rights reserved.>>
        <<David Goldberg November 13, 1989 8:28:33 pm PST>>
        <<Peter B. Kessler, January 10, 1990 10:46:47 am PST>>
        <<Theimer, September 10, 1990 2:12 pm PDT>>
        <<Last tweaked by Mike Spreitzer July 20, 1992 3:09 pm PDT>>
        <<Willie-s, May 5, 1992 12:20 pm PDT>>

    DIRECTORY
        Basics USING [CompareInt],
        BasicTime,
        Commander USING [CommandProc, Register],
        CommanderOps,
        Convert USING [RopeFromTime, IntFromRope],
        IO,
        List USING [CompareProc, LORA, Sort],
        Remind,
        Rope,
        TimeParse,
        UserProfile USING [CallWhenProfileChanges, ProfileChangedProc, Number];

    <<Commander commands for accessing Remind functionality.  Also adds button to walnut (this in here mainly to save a GFI).>>

    RemindUI: CEDAR PROGRAM
    IMPORTS 
        Basics, BasicTime, Commander, CommanderOps, Convert, IO, List, Remind, Rope, TimeParse, UserProfile
    = BEGIN OPEN Remind;

        ROPE: TYPE = Rope.ROPE;

        alNumRope: Rope.ROPE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

        Compare: List.CompareProc = {
            <<PROC[ref1: REF ANY, ref2: REF ANY] RETURNS [Comparison];>>
            p1, p2: REF TimeParse.PieceType;

            p1 Ź NARROW[ref1];
            p2 Ź NARROW[ref2];
            RETURN[Basics.CompareInt[p1.start, p2.start]];
            };

        WhiteSpace: IO.BreakProc = {
            RETURN[SELECT char FROM ' , '\n, '\t, '\l => sepr, ENDCASE => other];
            };

        StripTrailingNewline: PROC[inStr: Rope.ROPE] RETURNS [Rope.ROPE] = {
            ch: CHAR;

            ch Ź Rope.Fetch[inStr, Rope.Length[inStr]-1];
            IF ch = '\n OR ch = '\r THEN inStr Ź Rope.Substr[inStr, 0, Rope.Length[inStr] - 1];
            RETURN[inStr];
            };

        OldRemind: Commander.CommandProc = {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL];>>
            time: BasicTime.GMT;
            inStr: Rope.ROPE;
            i: INT;

            IF (i Ź Rope.Find[cmd.commandLine, "/"]) # -1 THEN
                inStr Ź Rope.Substr[cmd.commandLine, 0, i]
            ELSE
                inStr Ź cmd.commandLine;
            inStr Ź StripTrailingNewline[inStr];
            time Ź TimeParse.Parse[inStr, BasicTime.Now[] !
                TimeParse.ParseError => {cmd.out.PutRope["Couldn't parse the time\n"]; GOTO done;};
            ].time;
            CreateAndAddMeeting[time, inStr, cmd.out, IO.RIS[Rope.Substr[cmd.commandLine, i+1]], i # -1];
            EXITS
                done => NULL;
            };

        Remind: Commander.CommandProc = {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL];>>
            time: BasicTime.GMT;
            inStr, newStr: Rope.ROPE;
            i: INT;
            ok: BOOLEAN;

            IF (i Ź Rope.Find[cmd.commandLine, "/"]) # -1 THEN
                inStr Ź Rope.Substr[cmd.commandLine, 0, i]
            ELSE
                inStr Ź cmd.commandLine;
            inStr Ź StripTrailingNewline[inStr];
            [time, newStr, ok] Ź RopeToTime[inStr, cmd.out];
            IF ok THEN 
                CreateAndAddMeeting[time, inStr, cmd.out, IO.RIS[Rope.Substr[cmd.commandLine, i+1]], i # -1];
            };

        CreateAndAddMeeting: PROC[time: BasicTime.GMT, str: Rope.ROPE, outStrm, optStrm: IO.STREAM, options: BOOLEAN] = {
            meeting: Meeting;
            rmd: Reminder;
            token1, token2: Rope.ROPE;
            remindLeadTime, remindDuration: INT;

            meeting Ź NEW[MeetingRec];
            meeting.duration Ź defaultDuration;
            remindDuration Ź defaultRemindDuration;
            remindLeadTime Ź defaultRemindLeadTime;
            outStrm.PutF1["Time parsed as %g\n", IO.time[time]];
            IF options THEN {
                WHILE TRUE DO {
                    ENABLE BadData => {outStrm.PutF1["Couldn't parse %g\n", IO.rope[token1]]; LOOP};
                    token1 Ź IO.GetTokenRope[optStrm, WhiteSpace ! IO.EndOfStream => EXIT].token; 
                    token2 Ź IO.GetTokenRope[optStrm, WhiteSpace ! IO.EndOfStream => EXIT].token; 
                    SELECT TRUE FROM
                        Rope.Equal[token1, "repeat", FALSE] => meeting.repeat Ź RepetitionFromRope[token2];
                        Rope.Equal[token1, "duration", FALSE] => meeting.duration Ź Convert.IntFromRope[token2];
                        Rope.Equal[token1, "RemindLeadTime", FALSE] => remindLeadTime Ź Convert.IntFromRope[token2];
                        Rope.Equal[token1, "RemindDuration", FALSE] => remindDuration Ź Convert.IntFromRope[token2];
                        Rope.Equal[token1, "more", FALSE] => meeting.more Ź token2;
                        Rope.Equal[token1, "iconLabel", FALSE] => meeting.iconLabel Ź token2;
                        Rope.Equal[token1, "iconFlavor", FALSE] => meeting.iconFlavor Ź token2;
                        ENDCASE => outStrm.PutF1["Couldn't parse %g\n", IO.rope[token1]];
                    };
                    ENDLOOP;
                };
            <<meeting.explanation _ newStr;>>
            meeting.explanation Ź str;
            meeting.start Ź time;
            rmd Ź NEW [ReminderRecord Ź [NIL, alert[
                start: BasicTime.Update[time, -60*remindLeadTime],
                stop: BasicTime.Update[time, 60*(-remindLeadTime + remindDuration)]
                ]]];
            meeting.reminders Ź LIST[rmd];
            [] Ź AddMeeting[meeting];
            };

        RopeToTime: PROC[str: Rope.ROPE, strm: IO.STREAM] RETURNS [time: BasicTime.GMT, newStr: Rope.ROPE, ok: BOOLEAN Ź FALSE] = {
            cnt, len: INT;
            pieces: TimeParse.PiecesType;
            piecesLora: List.LORA;
            piece: REF TimeParse.PieceType;

            ListToLora: PROC[ls: TimeParse.PiecesType] RETURNS [lr: List.LORA Ź NIL] = {
            WHILE ls # NIL DO
                lr Ź CONS[ls.first, lr];
                ls Ź ls.rest;
                ENDLOOP;
                };

            BEGIN
            ENABLE TimeParse.ParseError => {
            SELECT errorType FROM
                noTime => IO.PutRope[strm, "No time specified\n"];
                yearOrMonthButNoDay => IO.PutRope[strm, "Doesn't make sense to have year/month but no day\n"];
                yearButNoMonth => IO.PutRope[strm, "Doesn't make sense to have year but no month\n"];
                dayWeekdayMismatch => IO.PutRope[strm, "Mismatch between weekday and date\n"];
                badYearInSlash => IO.PutRope[strm, "mm/dd/yy has invalid value for year\n"];
                twoYears => IO.PutRope[strm, "The year is specified in two different ways\n"];
                ENDCASE => NULL;
            GOTO done;
            };
            [time, pieces] Ź TimeParse.Parse[str, BasicTime.Now[]];
            cnt Ź 0;
            piecesLora Ź List.Sort[ListToLora[pieces], Compare];
            WHILE piecesLora # NIL DO
                piece Ź NARROW[piecesLora.first];
                len Ź piece.len;
                <<if there is only punctuation between two pieces, remove the punctuation>>
                IF piecesLora.rest # NIL AND Rope.SkipTo[str, piece.start - cnt + len, alNumRope] >= NARROW[pieces.rest.first, REF 
                TimeParse.PieceType].start  - cnt THEN
                    len Ź NARROW[pieces.rest.first, REF TimeParse.PieceType].start - piece.start;
                str Ź Rope.Replace[str, piece.start - cnt, len];
                cnt Ź cnt + len;
                piecesLora Ź piecesLora.rest;
                ENDLOOP;
            ok Ź TRUE;
            EXITS
                done => NULL;
            END;
            newStr Ź str;
            };

        DeleteByTime: Commander.CommandProc = {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL];>>
            time: BasicTime.GMT;
            ok: BOOLEAN;
            cnt: INT Ź 0;
            ls: LIST OF Meeting;

            [time: time, ok: ok] Ź RopeToTime[cmd.commandLine, cmd.out];
            IF ok THEN {
                ls Ź ListMeetings[time, time];
                FOR aList: LIST OF Meeting Ź ls, aList.rest UNTIL aList = NIL DO
                    IF aList.first.start = time THEN
                        {IF DeleteMeeting[aList.first.start, aList.first.uniqID] THEN cnt Ź cnt + 1;};
                    ENDLOOP;
                };
            cmd.out.PutF["Deleted %g meeting%g\n", IO.int[cnt], IO.char[IF cnt = 1 THEN '  ELSE 's]];
            };

        DeleteAll: Commander.CommandProc = {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL];>>
            cnt: INT Ź 0;
            ls: LIST OF Meeting;
            str: Rope.ROPE;

            IO.PutRope[cmd.out, "Really Delete everything? "];
            str Ź IO.GetLineRope[cmd.in];
            IF Rope.Fetch[str, 0] = 'y OR Rope.Fetch[str, 0] = 'Y THEN {
                cnt Ź DeleteAllMeetings[];
                cmd.out.PutF["Deleted %g meeting%g\n", IO.int[cnt], IO.char[IF cnt = 1 THEN '  ELSE 's]];
                };
            };

        Prune: Commander.CommandProc = {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL];>>
            cnt: INT Ź 0;
            ls: LIST OF Meeting;
            str: Rope.ROPE;
            time: BasicTime.GMT;

            IF CommanderOps.NumArgs[cmd] >  1 THEN  {
                time Ź TimeParse.Parse[cmd.commandLine, BasicTime.Now[] ! TimeParse.ParseError =>
                    {cmd.out.PutRope["Couldn't parse the time\n"]; GOTO done;};
                    ].time
            }
            ELSE {
                time Ź BasicTime.Now[];
                time Ź TimeParse.Adjust[baseTime: time, precisionOfResult: days].time;
            };
            IO.PutF1[cmd.out, "This will delete all one-time meetings Previous to %g, OK? ", IO.time[time]];
            str Ź IO.GetLineRope[cmd.in];
            IF Rope.Fetch[str, 0] = 'y OR Rope.Fetch[str, 0] = 'Y THEN {
                ls Ź ListMeetings[from: time.Update[-86400*365*2], to: time, all: FALSE];
                FOR aList: LIST OF Meeting Ź ls, aList.rest UNTIL aList = NIL DO
                    IF aList.first.repeat = once AND DeleteMeeting[aList.first.start, aList.first.uniqID, FALSE] THEN {
                        cnt Ź cnt + 1;
                        cmd.out.PutRope["*"];
                        }
                    <<IF aList.first.repeat = once THEN {cmd.out.PutF["Deleted %g\n", IO.rope[aList.first.explanation]]; cnt _ cnt + 1};>>
                    ENDLOOP;
                cmd.out.PutF["\nDeleted %g meeting%g\n", IO.int[cnt], IO.char[IF cnt = 1 THEN '  ELSE 's]];
                cmd.out.PutRope["Compacting Log.... "];
                CompactDb[];
                cmd.out.PutRope["\n"];
                CloseDb[];
                };
            EXITS
                done => NULL;
            };

        Compact: Commander.CommandProc = {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL];>>

            cmd.out.PutRope["Compacting Log.... "];
            CompactDb[];
            cmd.out.PutRope["\n"];
            CloseDb[];
            };

        CompareUsingStart: List.CompareProc = {
            <<PROC [ref1: REF ANY, ref2: REF ANY] RETURNS [Comparison]>>
            m1, m2: Meeting;

            m1 Ź NARROW[ref1];
            m2 Ź NARROW[ref2];
            RETURN[Basics.CompareInt[0, BasicTime.Period[m1.start, m2.start]]];
            };

        Read: Commander.CommandProc = {
            <<PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL];>>
            argv: CommanderOps.ArgumentVector ~ CommanderOps.Parse[cmd];
            ls: LIST OF Meeting;
            lsLora: List.LORA;

            ListToLora: PROC[ls: LIST OF Meeting] RETURNS [lr: List.LORA Ź NIL] = {
            WHILE ls # NIL DO
                lr Ź CONS[ls.first, lr];
                ls Ź ls.rest;
                ENDLOOP;
                };

            SELECT argv.argc FROM
                1, 2 => {
                    date: BasicTime.GMT ~ IF argv.argc>1
                        THEN TimeParse.Parse[argv[1], BasicTime.Now[], heuristic, FALSE, FALSE].time
                        ELSE BasicTime.Now[];
                    upkd: BasicTime.Unpacked Ź date.Unpack[];
                    start: BasicTime.GMT;
                    upkd.hour Ź upkd.minute Ź upkd.second Ź 0;
                    start Ź upkd.Pack[];
                    ls Ź ListMeetings[start, start.Update[86399]]};
                3 => {
                    from: BasicTime.GMT ~ TimeParse.Parse[argv[1], BasicTime.Now[], heuristic, FALSE, FALSE].time;
                    to: BasicTime.GMT ~ TimeParse.Parse[argv[2], BasicTime.Now[], heuristic, FALSE, FALSE].time;
                    ls Ź ListMeetings[from, to]};
                ENDCASE => CommanderOps.Failed[Rope.Cat["Usage: ", argv[0], " [date | from-time to-time]"]];
            lsLora Ź List.Sort[ListToLora[ls], CompareUsingStart];
            FOR aList: List.LORA Ź lsLora, aList.rest UNTIL aList = NIL DO
                PrintMeeting[cmd.out, NARROW[aList.first]];
                cmd.out.PutRope["\n"];
                ENDLOOP;
            RETURN};

        PrintMeeting: PROC[strm: IO.STREAM, meeting: Meeting] = {
            <<strm.PutF["start: %g\n", IO.rope[Convert.RopeFromTime[from: meeting.start, end: seconds]]];>>
            strm.PutF1["start: %g\n", IO.rope[Convert.RopeFromTime[meeting.start]]];
            strm.PutF1["duration: %g\n", IO.int[meeting.duration]];
            strm.PutF1["explanation: %g\n", IO.rope[meeting.explanation]];
            IF meeting.repeat # once THEN
                strm.PutF1["repeated %g\n", IO.rope[RopeFromRepetition[meeting.repeat]]];
            FOR rl: RemindList Ź meeting.reminders, rl.rest WHILE rl#NIL DO
                WITH rl.first SELECT FROM
                    x: REF ReminderRecord[alert] => strm.PutF[
                        "Alert Lead Time: %g\nAlert Duration: %g\n",
                        [integer[(BasicTime.Period[x.start, meeting.start] + 30)/60]],
                        [integer[(BasicTime.Period[x.start, x.stop] + 30)/60]]
                        ];
                    x: REF ReminderRecord[mail] => strm.PutF[
                        "Mail Lead Time: %g, Recipient: %g\n",
                        [integer[(BasicTime.Period[x.when, meeting.start] + 30)/60]],
                        [rope[x.to]] ];
                    ENDCASE => ERROR;
                ENDLOOP;
            IF meeting.more # NIL AND NOT Rope.IsEmpty[meeting.more] THEN
                strm.PutF1["More: %g\n", IO.rope[meeting.more]];
            IF meeting.iconLabel # NIL AND NOT Rope.IsEmpty[meeting.iconLabel] THEN
                strm.PutF1["Icon Label: %g\n", IO.rope[meeting.iconLabel]];
            IF meeting.iconFlavor # NIL AND NOT Rope.IsEmpty[meeting.iconFlavor] THEN
                strm.PutF1["Icon Flavor: %g\n", IO.rope[meeting.iconFlavor]];
            };

        UpdateDefaults: UserProfile.ProfileChangedProc = {
            <<PROC [reason: UserProfile.ProfileChangeReason]>>

            defaultRemindLeadTime Ź UserProfile.Number["Remind.RemindLeadTime", 20];
            defaultRemindDuration Ź UserProfile.Number["Remind.RemindDuration", 20];
            defaultDuration Ź UserProfile.Number["Remind.Duration", 60];
            };

        GetParameters: PROC[meeting: Meeting, str: Rope.ROPE, outStrm: IO.STREAM] RETURNS [timeSpecified: BOOLEAN Ź FALSE, remindDuration, 
        remindLeadTime: INT]= {
            token1, token2: Rope.ROPE;
            optStrm: IO.STREAM Ź IO.RIS[str];

            remindDuration Ź defaultRemindDuration;
            remindLeadTime Ź defaultRemindLeadTime;
            meeting.duration Ź defaultDuration;
            WHILE TRUE DO {
                ENABLE BadData => {outStrm.PutF1["Couldn't parse %g\n", IO.rope[token1]]; LOOP};
                token1 Ź IO.GetTokenRope[optStrm, WhiteSpace ! IO.EndOfStream => EXIT].token; 
                token2 Ź IO.GetTokenRope[optStrm, WhiteSpace ! IO.EndOfStream => EXIT].token; 
                SELECT TRUE FROM
                    Rope.Equal[token1, "start", FALSE] => {
                        IF switchToNew THEN meeting.start Ź TimeParse.Parse[token2, BasicTime.Now[]].time
                        ELSE
                            meeting.start Ź TimeParse.Parse[token2, BasicTime.Now[]].time;
                        timeSpecified Ź TRUE;
                        };
                    Rope.Equal[token1, "repeat", FALSE] => meeting.repeat Ź RepetitionFromRope[token2];
                    Rope.Equal[token1, "duration", FALSE] => meeting.duration Ź Convert.IntFromRope[token2];
                    Rope.Equal[token1, "RemindLeadTime", FALSE] => remindLeadTime Ź Convert.IntFromRope[token2];
                    Rope.Equal[token1, "RemindDuration", FALSE] => remindDuration Ź Convert.IntFromRope[token2];
                    Rope.Equal[token1, "more", FALSE] => meeting.more Ź token2;
                    Rope.Equal[token1, "iconLabel", FALSE] => meeting.iconLabel Ź token2;
                    Rope.Equal[token1, "iconFlavor", FALSE] => meeting.iconFlavor Ź token2;
                    ENDCASE => outStrm.PutF1["Couldn't parse %g\n", IO.rope[token1]];
                };
                ENDLOOP;
            };

    ParseErrorTypeName: ARRAY TimeParse.ParseErrorType OF ROPE
        ~ [noTime: "noTime", yearOrMonthButNoDay: "yearOrMonthButNoDay", yearButNoMonth: "yearButNoMonth", dayWeekdayMismatch: 
        "dayWeekdayMismatch", twoYears: "twoYears", badYearInSlash: "badYearInSlash"];

    TestParse: Commander.CommandProc ~ {
        argv: CommanderOps.ArgumentVector ~ CommanderOps.Parse[cmd];
        direction: TimeParse.DirectionType Ź heuristic;
        insistTime, insistDay: BOOL Ź TRUE;
        FOR i: INT IN (0..argv.argc) DO
            arg: ROPE ~ argv[i];
            SELECT TRUE FROM
                arg.Equal["heuristic"] => direction Ź heuristic;
                arg.Equal["forward"] => direction Ź forward;
                arg.Equal["backward"] => direction Ź backward;
                arg.Equal["-insistTime"] => insistTime Ź FALSE;
                arg.Equal["+insistTime"] => insistTime Ź TRUE;
                arg.Equal["-insistDay"] => insistDay Ź FALSE;
                arg.Equal["+insistDay"] => insistDay Ź TRUE;
                ENDCASE => {
                    now: BasicTime.GMT ~ BasicTime.Now[];
                    time: BasicTime.GMT;
                    pieces: TimeParse.PiecesType;
                    [time, pieces] Ź TimeParse.Parse[arg, now, direction, insistTime, insistDay ! TimeParse.ParseError => {
                        cmd.err.PutF1["ParseError[%g]\n", [rope[ParseErrorTypeName[errorType]]] ];
                        GOTO Not}];
                    cmd.out.PutRope[Convert.RopeFromTime[from: time, end: seconds]];
                    FOR pieces Ź pieces, pieces.rest WHILE pieces#NIL DO
                        cmd.out.PutF[" [%g, %g]", [integer[pieces.first.start]], [integer[pieces.first.len]] ];
                        ENDLOOP;
                    cmd.out.PutRope["\n"];
                    EXITS Not => NULL};
            ENDLOOP;
        RETURN};

    PrecisionNames: ARRAY TimeParse.Precision OF ROPE
        ~ [years: "years", months: "months", days: "days", hours: "hours", minutes: "minutes", seconds: "seconds", unspecified: 
        "unspecified"];

    TestTempusParse: Commander.CommandProc ~ {
        argv: CommanderOps.ArgumentVector ~ CommanderOps.Parse[cmd];
        search: BOOL Ź TRUE;
        FOR i: INT IN (0..argv.argc) DO
            arg: ROPE ~ argv[i];
            SELECT TRUE FROM
                arg.Equal["-search"] => search Ź FALSE;
                arg.Equal["+search"] => search Ź TRUE;
                ENDCASE => {
                    now: BasicTime.GMT ~ BasicTime.Now[];
                    time: BasicTime.GMT;
                    precision: TimeParse.Precision;
                    start, length: NAT;
                    [time, precision, start, length] Ź TimeParse.TempusParse[arg, now, search ! TimeParse.ParseError => {
                        cmd.err.PutF1["ParseError[%g]\n", [rope[ParseErrorTypeName[errorType]]] ];
                        GOTO Not}];
                    cmd.out.PutFL["time=%g, precision=%g, start=%g, length=%g\n",
                        LIST[[rope[Convert.RopeFromTime[from: time, end: seconds]]],
                        [rope[PrecisionNames[precision]]],
                        [integer[start]], [integer[length]]] ];
                    EXITS Not => NULL};
            ENDLOOP;
        RETURN};

    defaultRemindLeadTime, defaultRemindDuration, defaultDuration: INT Ź 0;
    walnutUser: BOOLEAN Ź FALSE;
    <<peanutUser: BOOLEAN _ FALSE;>>
    switchToNew: BOOLEAN Ź FALSE;

    UserProfile.CallWhenProfileChanges[UpdateDefaults];

    Commander.Register[
        key: "NewRemind",
        proc: Remind,
        doc: "Add item to database in style of \"remember\" using new parser" ];

    Commander.Register[
        key: "remind",
        proc: OldRemind,
        doc: "Add item to database in style of \"remember\" using tempus parser" ];

    Commander.Register[
        key: "DeleteByTimeFromCal",
        proc: DeleteByTime,
        doc: "Delete all meetings at given time from database" ];

    Commander.Register[
        key: "DeleteAllFromCalendar",
        proc: DeleteAll,
        doc: "Delete all meetings" ];

    Commander.Register[
        key: "PruneCalendar",
        proc: Prune,
        doc: "  CalPrune [Date]\n\tDelete old meetings and then Compact the loganberry files" ];

    Commander.Register[
        key: "PackCalendar",
        proc: Compact,
        doc: "  Compact the loganberry files" ];

    Commander.Register[
        key: "ShowCalendar",
        proc: Read,
        doc: "[date | from to] --- print contents of database" ];

    Commander.Register[
        key: "TimeParse.Parse",
        proc: TestParse,
        doc: "(heuristic|forward|backward|(+|-)(insistTime|insistDay)|<str>)* --- test TimeParse.Parse" ];

    Commander.Register[
        key: "TimeParse.TempusParse",
        proc: TestTempusParse,
        doc: "((+|-)search|<rope>)* --- test TimeParse.TempusParse" ];

    END.