/*
 * GLIB - a Generic LIBrarian and editor for synths
 *
 * Machine dependent stuff.
 *
 * Amiga version.
 */

#include "glib.h"
#include <stdio.h>
#include <ctype.h>

#include <dos.h>
#include <intuition/intuition.h>
#include <exec/types.h>
#include <exec/ports.h>
#include <exec/io.h>
#include <exec/devices.h>
#include <exec/memory.h>
#include <devices/serial.h>

#include <proto/exec.h>
#include <proto/intuition.h>

struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;
struct Screen *S;
struct Window *W;
struct RastPort *R;

int Rows, Cols;

#define TOPEDGE 8       /* how much of screen bar to show */
int WindowWidth = 640;
int WindowHeight = 200 - TOPEDGE;

/* standard WB colors */
#define BLUE 0
#define WHITE 1
#define BLACK 2
#define ORANGE 3


hello()
{
        windinit();
        openmidi();
}

bye()
{
        closemidi();
        windexit(0);
}

int MouseX, MouseY, MouseButtons;
int Mouseok = 0;

/* getmouse - get current row and column of mouse */
getmouse(amr,amc)
int *amr;
int *amc;
{
        *amr = MouseY / 8;
        *amc = MouseX / 8;
}

/* statmouse - return mouse button state (0=nothing pressed,1=left,2=right) */
statmouse()
{
        nextevent(MOUSEBUTTONS, 0);
        return MouseButtons;
}

/* Return when either a console key or mouse button is pressed. */
mouseorkey()
{
        return nextevent(MOUSEBUTTONS | VANILLAKEY, 1);
}

flushconsole()
{
        while (nextevent(VANILLAKEY, 0) >= 0) ;
}

getconsole()
{
        return nextevent(VANILLAKEY, 1);
}

cursor(state)
int state;
{
        int x, y;
        x = R->cp_x;
        y = R->cp_y - R->Font->tf_Baseline;
        SetDrMd(R, COMPLEMENT);
        RectFill(R, x, y, x+8, y+R->Font->tf_YSize-1);
        SetDrMd(R, JAM2);
}

nextevent(flags, wait)
long flags;
int wait;
{
        register int class, code;
        register struct IntuiMessage *message;
        int result;

        cursor(1);
        ModifyIDCMP(W, CLOSEWINDOW | flags);
        while (1)
        {
                if (wait)
                {
                    /* get next event, waiting if none are available */
                    while ((message = (struct IntuiMessage *)GetMsg(W->UserPort)) == NULL)
                    {
                        Wait(1<<W->UserPort->mp_SigBit);
                    }
                }
                else
                {
                    /* get next event, but return if none are available */
                    message = (struct IntuiMessage *)GetMsg(W->UserPort);
                    if (message == NULL)
                    {
                        result = -1;
                        break;
                    }
                }
                class = message->Class;
                code = message->Code;
                MouseX = message->MouseX;
                MouseY = message->MouseY;
                ReplyMsg((struct Message *)message);

                switch (class)
                {
                case VANILLAKEY:
                        result = code;
                        break;
                case CLOSEWINDOW:
                        result = 'q';
                        break;
                case MOUSEBUTTONS:
                        switch (code)
                        {
                        case SELECTDOWN:
                                MouseButtons = 1;
                                break;
                        case MENUDOWN:
                                MouseButtons = 2;
                                break;
                        default:
                                MouseButtons = 0;
                                break;
                        }
                        result = MOUSE;
                        break;
                default:
                        continue;
                }
                break;
        }
        cursor(0);
        return result;
}

/*------------------------------------------------------------------------
 * MIDI I/O Routines for Amiga.
 *
 * Uses low-level serial I/O for simultaneous reads and writes.
 */

struct MsgPort  *MidiInPort, *MidiOutPort;
struct IOExtSer *MidiIn, *MidiOut;
int     SerOpen = 0;

char    MidiInBuf;
int     MidiDataAvail = 0;

/*
 * start an asynchronous read request from MIDI IN
 */

startmidiread()
{
        MidiIn->IOSer.io_Data = (APTR) &MidiInBuf;
        MidiIn->IOSer.io_Length = 1;
        MidiIn->IOSer.io_Command = CMD_READ;
        MidiIn->IOSer.io_Flags = IOF_QUICK;     /* use quick I/O */
        BeginIO((struct IORequest *) MidiIn);
        /* did I/O complete quickly? */
        if ((MidiIn->IOSer.io_Flags & IOF_QUICK)) {
                /* wow, data's coming in fast! */
                MidiDataAvail = 1;
        } else {
                /* no data this time, it'll arrive later */
                MidiDataAvail = 0;
        }
}

/*
 * get a byte from MIDI IN.
 * assumes startmidiread has been previously done.  if statmidi has been
 * checked, this function will not wait.  otherwise, it will wait for
 * a single byte to arrive if none is available.
 */

getmidi()
{
        register struct Message *io;
        int result;

        /* return previously-received data, if available */
        if (MidiDataAvail) {
                result = MidiInBuf;
                /* start a new I/O */
                startmidiread();
                return result;
        }

        /* read next available byte */
        io = (struct Message *) CheckIO((struct IORequest *) MidiIn);
        if (io == FALSE) {
                /* wait for next byte */
                WaitIO((struct IORequest *) MidiIn);
                io = &MidiIn->IOSer.io_Message;
        }

        Remove(&io->mn_Node);
        result = MidiInBuf;
        startmidiread();        /* start I/O for next byte */
        return result;
}

/*
 * write a byte to MIDI OUT
 */

sendmidi(c)
int c;
{
        char    buf = c;

        MidiOut->IOSer.io_Data = (APTR) &buf;
        MidiOut->IOSer.io_Length = 1;
        MidiOut->IOSer.io_Command = CMD_WRITE;
        DoIO((struct IORequest *) MidiOut);     /* synchronous request */
}

/*
 * check if any midi data is waiting to be received
 */
statmidi()
{
        /* check if data has previously been received */
        if (MidiDataAvail) return 1;

        /* check if i/o has completed */
        return (CheckIO((struct IORequest *) MidiIn) == FALSE) ? 0 : 1;
}

openmidi()
{
        /* create message port for serial device */
        MidiInPort = (struct MsgPort *) CreatePort(SERIALNAME,0);
        if (MidiInPort == NULL) fatal("Can't create MidiInPort");

        /* create i/o request block for serial device */
        MidiIn = (struct IOExtSer *)
                CreateExtIO(MidiInPort, sizeof(struct IOExtSer));
        if (MidiIn == NULL) fatal("Can't create MidiIn");

        /* open the serial device */
        MidiIn->io_SerFlags = SERF_SHARED;
        SerOpen = OpenDevice(SERIALNAME,0,(struct IORequest *) MidiIn,0) == 0 ? 1 : 0;
        if (SerOpen == 0) fatal("Can't open serial.device");

        /* set serial device parameters */
        MidiIn->io_Baud = 31250;
        MidiIn->io_RBufLen = 8192;      /* large input buffer - if your synth
                                         * sends dumps larger than this you
                                         * will have to increase it. */
        MidiIn->io_SerFlags = SERF_RAD_BOOGIE;
        MidiIn->IOSer.io_Command = SDCMD_SETPARAMS;
        DoIO((struct IORequest *) MidiIn);

        /* clone MidiIn into MidiOut to allow simultaneous i/o */
        MidiOutPort = (struct MsgPort *) CreatePort("MidiOut",0);
        if (MidiOutPort == NULL) fatal("Can't create MidiOutPort");

        MidiOut = (struct IOExtSer *)
                        CreateExtIO(MidiOutPort, sizeof(struct IOExtSer));
        *MidiOut = *MidiIn;
        MidiOut->IOSer.io_Message.mn_ReplyPort = MidiOutPort;

        /* get the MIDI IN port started */
        startmidiread();
}

closemidi()
{
        if (SerOpen) CloseDevice((struct IORequest *)MidiIn);
        if (MidiIn) DeleteExtIO((struct IORequest *)MidiIn);
        if (MidiOut) DeleteExtIO((struct IORequest *)MidiOut);
        if (MidiInPort) DeletePort(MidiInPort);
        if (MidiOutPort) DeletePort(MidiOutPort);
}

flushmidi()
{
        while ( STATMIDI )
                getmidi();
}

long milliclock()
{
        unsigned int clock[2];
        long milli;
        timer(clock);
        milli = clock[0] * 1000 + clock[1] / 1000;
        return milli;
}

millisleep(n)
{
        Delay(n/20);
}

char *
alloc(n)
{
        char *p;

        if ( (p=malloc((unsigned)n)) == (char *)NULL ) {
                fatal("GLIB is out of memory!");
        }
        return(p);
}

struct TextAttr font =
{
        "topaz.font",TOPAZ_EIGHTY,FS_NORMAL,FPF_ROMFONT
};

struct NewScreen ns =
{
        0,0,640,200,2,BLACK,WHITE,HIRES,CUSTOMSCREEN,&font,"",NULL,NULL
};

windinit()
{
        struct NewWindow nw;

        if (S != NULL) return;

        IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library", 0);
        GfxBase = (struct GfxBase *) OpenLibrary("graphics.library",0);
        if (IntuitionBase == NULL || GfxBase == NULL) exit(1);

        if ((S = (struct Screen *) OpenScreen(&ns)) == NULL) exit(1);

        nw.LeftEdge = 0;
        nw.TopEdge = TOPEDGE;
        nw.Width = WindowWidth;
        nw.Height = WindowHeight;
        nw.DetailPen = BLACK;
        nw.BlockPen = WHITE;
        nw.Title = NULL;
        nw.Flags = SMART_REFRESH | ACTIVATE | BACKDROP |
                   BORDERLESS | NOCAREREFRESH | RMBTRAP;
        nw.IDCMPFlags = CLOSEWINDOW | VANILLAKEY;
        nw.Type = CUSTOMSCREEN;
        nw.FirstGadget = NULL;
        nw.CheckMark = NULL;
        nw.Screen = S;
        nw.BitMap = NULL;
        if ((W = (struct Window *) OpenWindow(&nw)) == NULL) exit(1);
        R = W->RPort;
        SetAPen(R, ORANGE);
        SetBPen(R, BLACK);
        ShowTitle(S, FALSE);
        Cols=80;
        Rows=24;
}

windgoto(r,c)
int r,c;
{
        Move(R, c*8, r*8 + R->Font->tf_Baseline);
}

windeeol()
{
        int x, y;
        x = R->cp_x;
        y = R->cp_y  - R->Font->tf_Baseline;
        SetAPen(R, BLACK);
        RectFill(R, x, y, WindowWidth, y+R->Font->tf_YSize-1);
        SetAPen(R, ORANGE);
}

winderaserow(r)
{
        windgoto(r,0);
        windeeol();
}

windexit(r)
int r;
{
        if (W) CloseWindow(W);
        if (S) CloseScreen(S);
        exit(r);
}

windclear()
{
        SetAPen(R, BLACK);
        RectFill(R, 0, 0, WindowWidth, WindowHeight);
        SetAPen(R, ORANGE);
}

/* windgets - get a line of input from the console, handling backspaces */
windgets(s)
char *s;
{
        char *origs = s;
        int c;

        SetAPen(R, WHITE);
        while ( (c=getconsole()) != '\n' && c!='\r' && c!= EOF ) {
                if ( c == '\b' ) {
                        if ( s > origs ) {
                                wbackspace();
                                s--;
                        }
                }
                else if (c == 24) {
                        while (s > origs) {
                                wbackspace();
                                s--;
                        }
                } else if (isprint(c)) {
                        windputc(c);
                        *s++ = c;
                }
                windrefresh();
        }
        *s = '\0';
        SetAPen(R, ORANGE);
}

windstr(s)
char *s;
{
        Text(R, s, strlen(s));
}

windputc(c)
int c;
{
        char s = c;
        Text(R, &s, 1);
}

wbackspace()
{
        int x, y;
        x = R->cp_x;
        y = R->cp_y;
        Move(R, x-8, y);
        windputc(' ');
        Move(R, x-8, y);
}

windrefresh()
{
}

beep()
{
        DisplayBeep(S);
}

windhigh()
{
}

windnorm()
{
}

struct IntuiText fataltext = { 1,0,COMPLEMENT,16,32,NULL,NULL,NULL };
struct IntuiText canceltext = { 1,0,COMPLEMENT,2,2,NULL,"cancel",NULL };

fatal(text)
char *text;
{
        fataltext.IText = text;
        AutoRequest(W, &fataltext, NULL, &canceltext, 0, 0, 320, 90);
        bye();
}

/****************
 * openls(), nextls(), and closels() are used to scan the current directory.
 ***************/

struct FileInfoBlock *lsinfo = NULL;

openls()
{
}

char *
nextls()
{
        int error;
        if (lsinfo == NULL) {
                lsinfo = (struct FileInfoBlock *) alloc(sizeof(struct FileInfoBlock));
                error = dfind(lsinfo, "#?", 0);
        } else {
                error = dnext(lsinfo);
        }
        if (error == 0) {
                return lsinfo->fib_FileName;
        } else {
                return NULL;
        }
}

closels()
{
        free(lsinfo);
        lsinfo = NULL;
}