#include <exec/types.h>
#include <intuition/intuition.h>
#include <libraries/gadtools.h>

#include <stdlib.h>
#include "amigan.h"

IMPORT  struct AminetStruct aminet;
AGLOBAL struct AGDBStruct   agdb;

// from rp.c
IMPORT SBYTE                page;
IMPORT struct NewGadget*    Gadget;
IMPORT struct Gadget       *BU99_Right,
                           *BU99_TextEditor,
                           *PrevGadPtr;
IMPORT struct Window*       MainWindowPtr;
IMPORT struct SharedStruct  shared;
IMPORT ULONG                wbval, offset;
IMPORT TEXT                 IOBuffer[LONGESTFIELD + 1],
                            aslresult[MEDFIELD + 1],
                            string[VLONGFIELD + 1];
IMPORT ABOOL                fillwindows;

MODULE void updateagdbgadgets(void);
MODULE void readagdbgadgets(void);

MODULE struct Gadget *ST111_Title             = NULL,
                     *ST111_Publisher         = NULL,
                     *ST111_GameType          = NULL,
                     *ST111_Players           = NULL,
                     *ST111_HDInstallable     = NULL,
                     *ST111_Compatibility     = NULL,
                     *ST111_Submission        = NULL;

AGLOBAL void agdb1(void)
{   verynewwindow
    (   AGDBWIDTH, AGDBHEIGHT,
        "Report+: Amiga Games Database (AGDB) Review Details",
        BUTTONIDCMP | STRINGIDCMP
    );
    OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_NEW,    NOSUB));
    OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_OPEN,   NOSUB));
    OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_SAVE,   NOSUB));
    OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_SAVEAS, NOSUB));

    /* PAGE 111 ************************************************************/

    navigate();

    setgadget(200, 46, 350, 12, "_Title:", NULL);
    ST111_Title = PrevGadPtr = (struct Gadget *) CreateGadget
    (   STRING_KIND,
        PrevGadPtr,
        &Gadget,
        GTST_String,   &(agdb.title),
        GTST_MaxChars, 40,
        GA_TabCycle,   TRUE,
        GA_Immediate,  TRUE,
        GT_Underscore, '_',
        TAG_DONE
    );

    setgadget(200, 58, 350, 12, "_Publisher (Year):", NULL);
    ST111_Publisher = PrevGadPtr = (struct Gadget *) CreateGadget
    (   STRING_KIND,
        PrevGadPtr,
        &Gadget,
        GTST_String, &(agdb.publisher),
        GTST_MaxChars, 40,
        GA_TabCycle, TRUE,
        GA_Immediate, TRUE,
        GT_Underscore, '_',
        TAG_DONE
    );

    setgadget(200, 70, 350, 12, "_Game Type:", NULL);
    ST111_GameType = PrevGadPtr = (struct Gadget *) CreateGadget
    (   STRING_KIND,
        PrevGadPtr,
        &Gadget,
        GTST_String, &(agdb.gametype),
        GTST_MaxChars, 40,
        GA_TabCycle, TRUE,
        GA_Immediate, TRUE,
        GT_Underscore, '_',
        TAG_DONE
    );

    setgadget(200, 82, 350, 12, "P_layers:", NULL);
    ST111_Players = PrevGadPtr = (struct Gadget *) CreateGadget
    (   STRING_KIND,
	PrevGadPtr,
	&Gadget,
        GTST_String, &(agdb.players),
	GTST_MaxChars, 40,
	GA_TabCycle, TRUE,
	GA_Immediate, TRUE,
        GT_Underscore, '_',
	TAG_DONE
    );

    setgadget(200, 94, 350, 12, "_HD Installable?", NULL);
    ST111_HDInstallable = PrevGadPtr = (struct Gadget *) CreateGadget
    (   STRING_KIND,
	PrevGadPtr,
	&Gadget,
        GTST_String, &(agdb.hdinstallable),
	GTST_MaxChars, 40,
	GA_TabCycle, TRUE,
	GA_Immediate, TRUE,
        GT_Underscore, '_',
	TAG_DONE
    );

    setgadget(200, 106, 350, 12, "_Compatibility:", NULL);
    ST111_Compatibility = PrevGadPtr = (struct Gadget *) CreateGadget
    (	STRING_KIND,
	PrevGadPtr,
	&Gadget,
        GTST_String, &(agdb.compatibility),
	GTST_MaxChars, 40,
	GA_TabCycle, TRUE,
	GA_Immediate, TRUE,
        GT_Underscore, '_',
	TAG_DONE
    );

    if ((!(aminet.uploader[0])) && readin("S:Report.sender"))
    {   /* # Refer: <last>,<first> (<company> ,phone <phone>)<LF>
           # Path: <email><LF>
           # ReferID: <developer><LF> */

        offset = 0;
        parse("# Refer: ");
        parse(",");
        parse(" (");
        parse(" ,phone ");
        parse(")\n# Path: ");
        parse("\n# ReferID: ");
        strcpy(aminet.uploader, string);
    }

    setgadget(200, 118, 350, 12, "_Submission:", NULL);
    ST111_Submission = PrevGadPtr = (struct Gadget *) CreateGadget
    (   STRING_KIND,
        PrevGadPtr,
        &Gadget,
        GTST_String, &(aminet.uploader),
        GTST_MaxChars, 40,
        GA_TabCycle, TRUE,
        GA_Immediate, TRUE,
        GT_Underscore, '_',
        TAG_DONE
    );

    /* text editor... */
    setgadget(220, 24, 200, 12, "_Review...", NULL);
    BU99_TextEditor = PrevGadPtr = (struct Gadget *) CreateGadget
    (   BUTTON_KIND,
        PrevGadPtr,
        &Gadget,
        GT_Underscore, '_',
        TAG_DONE
    );

    /* There are 16 gadgets:
       button gadgets: 2x1= 2 BU99_Right, BU99_TextEditor
       string gadgets: 7x2=14 */
    drawgadgets(16);

    ActivateGadget(ST111_Title, MainWindowPtr, NULL);
    loop();

    readagdbgadgets();
    closewindow();
}

AGLOBAL void saveagdb(ABOOL saveas)
{   /*  Title            <title>
        Publisher        <publisher>
        Game Type        <game type>
        Players          <players>
        HD Installable   <hd installable>
        Compatibility    <compatibility>
        Submission       <uploader>
		
        Review
        <review> */

    readagdbgadgets();

    strcpy(IOBuffer, "Title:           ");
    strcat(IOBuffer, agdb.title);
    strcat(IOBuffer, "\nPublisher:       ");
    strcat(IOBuffer, agdb.publisher);
    strcat(IOBuffer, "\nGame Type:       ");
    strcat(IOBuffer, agdb.gametype);
    strcat(IOBuffer, "\nPlayers:         ");
    strcat(IOBuffer, agdb.players);
    strcat(IOBuffer, "\nHD Installable:  ");
    strcat(IOBuffer, agdb.hdinstallable);
    strcat(IOBuffer, "\nCompatibility:   ");
    strcat(IOBuffer, agdb.compatibility);
    strcat(IOBuffer, "\nSubmission:      ");
    strcat(IOBuffer, aminet.uploader);
    strcat(IOBuffer, "\n\nReview:\n");
    strcat(IOBuffer, agdb.textfield);

    if (!agdb.output[0] || saveas) // if we need a filename
    {   saveasl("Save AGDB Review");
        strcpy(agdb.output, aslresult);
    }
    if (agdb.output[0]) // if ASL was not cancelled
    {   writeout(agdb.output);
}   }

AGLOBAL void agdb_loop(ULONG class, struct Gadget* addr, UWORD code)
{       if (class == IDCMP_GADGETUP)
        {   if (addr == BU99_Right)
            {   page = 0;
            } elif (addr == BU99_TextEditor)
            {   if (wbval <= 43)
                {   saveagdb(FALSE);
                }
                launcheditor();
        }   }
        elif (class == IDCMP_VANILLAKEY)
        {   code = toupper(code);
            if (code == ESCAPE)
            {   page = 0;
            } elif (code == 'T')
            {   ActivateGadget(ST111_Title,         MainWindowPtr, NULL);
            } elif (code == 'P')
            {   ActivateGadget(ST111_Publisher,     MainWindowPtr, NULL);
            } elif (code == 'G')
            {   ActivateGadget(ST111_GameType,      MainWindowPtr, NULL);
            } elif (code == 'L')
            {   ActivateGadget(ST111_Players,       MainWindowPtr, NULL);
            } elif (code == 'H')
            {   ActivateGadget(ST111_HDInstallable, MainWindowPtr, NULL);
            } elif (code == 'C')
            {   ActivateGadget(ST111_Compatibility, MainWindowPtr, NULL);
            } elif (code == 'S')
            {   ActivateGadget(ST111_Submission,    MainWindowPtr, NULL);
            } elif (code == 'R')
            {   if (wbval <= 43)
                {   saveagdb(FALSE);
                }
                launcheditor();
}       }   }

AGLOBAL void newagdb(ABOOL display)
{   strcpy(agdb.title,         "");
    strcpy(agdb.publisher,     "");
    strcpy(agdb.gametype,      "");
    strcpy(agdb.players,       "");
    strcpy(agdb.hdinstallable, "");
    strcpy(agdb.compatibility, "");
    strcpy(aminet.uploader,    "");
    strcpy(agdb.output,        "");
    strcpy(agdb.textfield,     "");
    agdb.loaded = FALSE;

    if (display)
        updateagdbgadgets();
}

AGLOBAL void openagdb(void)
{   asl();
    if (aslresult[0])
    {   loadagdb();
        updateagdbgadgets();
    } else DisplayBeep(NULL);
}

AGLOBAL void loadagdb(void)
{   if (readin(aslresult))
    {   strcpy(agdb.output, aslresult);
        agdb.loaded = TRUE;
        offset = 0;

        parse("Title:           ");
        parse("\nPublisher:       ");
        strcpy(agdb.title,         string);
        parse("\nGame Type:       ");
        strcpy(agdb.publisher,     string);
        parse("\nPlayers:         ");
        strcpy(agdb.gametype,      string);
        parse("\nHD Installable:  ");
        strcpy(agdb.players,       string);
        parse("\nCompatibility:   ");
        strcpy(agdb.hdinstallable, string);
        parse("\nSubmission:      ");
        strcpy(agdb.compatibility, string);
        parse("\n\nReview:\n");
        strcpy(aminet.uploader,    string);
        parsetoend();
        strcpy(agdb.textfield,     string);

        updateagdbgadgets();
}   }

MODULE void updateagdbgadgets(void)
{   GT_SetGadgetAttrs
    (   ST111_Title,
        MainWindowPtr,
        NULL,
        GTST_String, agdb.title,
        TAG_DONE
    );
    GT_SetGadgetAttrs
    (   ST111_Publisher,
        MainWindowPtr,
        NULL,
        GTST_String, agdb.publisher,
        TAG_DONE
    );
    GT_SetGadgetAttrs
    (   ST111_GameType,
        MainWindowPtr,
        NULL,
        GTST_String, agdb.gametype,
        TAG_DONE
    );
    GT_SetGadgetAttrs
    (   ST111_Players,
        MainWindowPtr,
        NULL,
        GTST_String, agdb.players,
        TAG_DONE
    );
    GT_SetGadgetAttrs
    (   ST111_HDInstallable,
        MainWindowPtr,
        NULL,
        GTST_String, agdb.hdinstallable,
        TAG_DONE
    );
    GT_SetGadgetAttrs
    (   ST111_Compatibility,
        MainWindowPtr,
        NULL,
        GTST_String, agdb.compatibility,
        TAG_DONE
    );
    GT_SetGadgetAttrs
    (   ST111_Submission,
        MainWindowPtr,
        NULL,
        GTST_String, aminet.uploader,
        TAG_DONE
    );
}

MODULE void readagdbgadgets(void)
{   strcpy
    (   agdb.title,
        ((struct StringInfo *) ST111_Title->SpecialInfo)->Buffer
    );
    strcpy
    (   agdb.publisher,
        ((struct StringInfo *) ST111_Publisher->SpecialInfo)->Buffer
    );
    strcpy
    (   agdb.gametype,
        ((struct StringInfo *) ST111_GameType->SpecialInfo)->Buffer
    );
    strcpy
    (   agdb.players,
        ((struct StringInfo *) ST111_Players->SpecialInfo)->Buffer
    );
    strcpy
    (   agdb.hdinstallable,
        ((struct StringInfo *) ST111_HDInstallable->SpecialInfo)->Buffer
    );
    strcpy
    (   agdb.compatibility,
        ((struct StringInfo *) ST111_Compatibility->SpecialInfo)->Buffer
    );
    strcpy
    (   aminet.uploader,
        ((struct StringInfo *) ST111_Submission->SpecialInfo)->Buffer
    );
}