/*
 * Copyright (C) 1995-1997 Christopher D. Granz
 *
 * This header may not be removed.
 *
 * Refer to the file "License" included in this package for further
 * information and before using any of the following.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "sapphire.h"


/*
 * Functions
 */
void process_npc_editor_cmd( TERM_DATA *pTerm, char *pCommand )
{
    char cCommand[MAX_INPUT];
    int i;

    if ( next_char( pCommand ) == '\0' )
        return;

    if ( !isalnum( pCommand[0] ) )
    {
        cCommand[0] = pCommand[0];
        cCommand[1] = '\0';
        pCommand++;

        while ( *pCommand == ' ' )
            pCommand++;
    }
    else
        pCommand                  = one_arg( pCommand, cCommand );

    if ( is_number( cCommand ) == TRUE )
    {
        NPC_INDEX_DATA *pNPCIndex = get_npc_index( atoi( cCommand ) );

        if ( pNPCIndex == NULL )
        {
            write_string_buffer( pTerm, "No such NPC.\n\r" );
            return;
        }

        pTerm->uEdit.pEditNPC     = pNPCIndex;
        return;
    }

    for ( i = 0; olccNPCTable[i].pName[0] != '\0'; i++ )
    {
        if ( LOWER( cCommand[0] ) == LOWER( olccNPCTable[i].pName[0] )
        && str_prefix( cCommand, olccNPCTable[i].pName ) == TRUE )
        {
            ( *olccNPCTable[i].pCmdFunc ) ( pTerm, pCommand );
            return;
        }
    }

    write_string_buffer( pTerm, "I do not understand.\n\r" );
}


void process_object_editor_cmd( TERM_DATA *pTerm, char *pCommand )
{
    char cCommand[MAX_INPUT];
    int i;

    if ( next_char( pCommand ) == '\0' )
        return;

    if ( !isalnum( pCommand[0] ) )
    {
        cCommand[0] = pCommand[0];
        cCommand[1] = '\0';
        pCommand++;

        while ( *pCommand == ' ' )
            pCommand++;
    }
    else
        pCommand                  = one_arg( pCommand, cCommand );

    if ( is_number( cCommand ) == TRUE )
    {
        OBJ_INDEX_DATA *pObjIndex = get_object_index( atoi( cCommand ) );

        if ( pObjIndex == NULL )
        {
            write_string_buffer( pTerm, "No such object.\n\r" );
            return;
        }

        pTerm->uEdit.pEditObject  = pObjIndex;
        return;
    }

    for ( i = 0; olccObjectTable[i].pName[0] != '\0'; i++ )
    {
        if ( LOWER( cCommand[0] ) == LOWER( olccObjectTable[i].pName[0] )
        && str_prefix( cCommand, olccObjectTable[i].pName ) == TRUE )
        {
            ( *olccObjectTable[i].pCmdFunc ) ( pTerm, pCommand );
            return;
        }
    }

    write_string_buffer( pTerm, "I do not understand.\n\r" );
}


void process_room_editor_cmd( TERM_DATA *pTerm, char *pCommand )
{
    char cCommand[MAX_INPUT];
    int i;

    if ( next_char( pCommand ) == '\0' )
        return;

    if ( !isalnum( pCommand[0] ) )
    {
        cCommand[0] = pCommand[0];
        cCommand[1] = '\0';
        pCommand++;

        while ( *pCommand == ' ' )
            pCommand++;
    }
    else
        pCommand                    = one_arg( pCommand, cCommand );

    if ( is_number( cCommand ) == TRUE )
    {
        ROOM_INDEX_DATA *pRoomIndex = get_room_index( atoi( cCommand ) );

        if ( pRoomIndex == NULL )
        {
            write_string_buffer( pTerm, "No such room.\n\r" );
            return;
        }

        pTerm->uEdit.pEditRoom      = pRoomIndex;
        return;
    }

    for ( i = 0; olccRoomTable[i].pName[0] != '\0'; i++ )
    {
        if ( LOWER( cCommand[0] ) == LOWER( olccRoomTable[i].pName[0] )
        && str_prefix( cCommand, olccRoomTable[i].pName ) == TRUE )
        {
            ( *olccRoomTable[i].pCmdFunc ) ( pTerm, pCommand );
            return;
        }
    }

    write_string_buffer( pTerm, "I do not understand.\n\r" );
}


void cmd_edit( CHAR_DATA *pChar, char *pArgument )
{
    char cBuf[MAX_INPUT];

    if ( pChar->pTerm == NULL )
        return;

    if ( IS_NPC( pChar ) )
    {
        send_string( pChar, "Why would NPCs need to use OLC?\n\r" );
        return;
    }

    if ( pArgument[0] == '\0' )
    {
        send_string( pChar, "What is it you would like to edit?\n\r" );
        goto syntax;
    }

    pArgument                   = one_arg( pArgument, cBuf );

    if ( str_prefix( cBuf, "npc" ) == TRUE )
        pChar->pTerm->iConState = CON_NPC_EDITOR;
    else if ( str_prefix( cBuf, "object" ) == TRUE )
        pChar->pTerm->iConState = CON_OBJECT_EDITOR;
    else if ( str_prefix( cBuf, "room" ) == TRUE )
        pChar->pTerm->iConState = CON_ROOM_EDITOR;
    else
    {
        send_string( pChar, "That is not a valid option.\n\r" );
        goto syntax;
    }

    send_game_message( "~c has left this world.", MESSAGE_DEST_ROOM, TRUE,
      pChar, NULL, pChar->pInRoom, TRUE, NUMBER_POSITION_RESTING, pChar );
    char_from_room( pChar );
    write_string_buffer( pChar->pTerm, make_ansi_code(
      ANSI_CODEREF_EF_CSCREEN, NULL, NULL, pChar->pTerm ) );
    send_string( pChar, "\n\rType `done' to leave the editor.\n\r" );

    return;

syntax:
    send_string( pChar, "Valid editing options:\n\r"
      "  edit npc    - Enter the non-player character editor.\n\r"
      "  edit object - Enter the object editor.\n\r"
      "  edit room   - Enter the room editor.\n\r" );
}


void olc_cmd_who( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->pChar == NULL )
        return;

    cmd_who( pTerm->pChar, pArgs );
}


void olc_cmd_rwho( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->pChar == NULL )
        return;

    cmd_rwho( pTerm->pChar, pArgs );
}


void olc_cmd_ltell( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->pChar == NULL )
        return;

    cmd_ltell( pTerm->pChar, pArgs );
}


void olc_cmd_rtell( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->pChar == NULL )
        return;

    cmd_rtell( pTerm->pChar, pArgs );
}


void olc_cmd_chat( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->pChar == NULL )
        return;

    cmd_chat( pTerm->pChar, pArgs );
}


void olc_cmd_lwizcomm( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->pChar == NULL )
        return;

    cmd_wizcomm( pTerm->pChar, pArgs );
}


void olc_cmd_wizcomm( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->pChar == NULL )
        return;

    cmd_wizcomm( pTerm->pChar, pArgs );
}


void olc_cmd_done( TERM_DATA *pTerm, char *pArgs )
{
    pTerm->uEdit.pEditNPC    = NULL;
    pTerm->uEdit.pEditObject = NULL;
    pTerm->uEdit.pEditRoom   = NULL; /* just to be safe :) */

    char_to_room( pTerm->pChar, uDefaultRoom.pRoom );
    send_game_message( "~h appears out of nothingness.",
      MESSAGE_DEST_ROOM, TRUE, pTerm->pChar, NULL, pTerm->pChar->pInRoom,
      TRUE, NUMBER_POSITION_RESTING, pTerm->pChar );
    write_string_buffer( pTerm, make_ansi_code(
      ANSI_CODEREF_EF_CSCREEN, NULL, NULL, pTerm ) );

    pTerm->iConState         = CON_PLAYING;
}


void olc_cmd_room_new( TERM_DATA *pTerm, char *pArgs )
{
    ROOM_INDEX_DATA *pNewRoomIndex;
    char cBuf[128];
    int iNumber;
    int i;

    if ( pArgs[0] == '\0' )
    {
        for ( iNumber = 6; get_room_index( iNumber ) != NULL; iNumber++ )
        {
            if ( iNumber > MAX_INDEX_NUMBER )
            {
                write_string_buffer( pTerm,
                  "Cannot create new room; out of space.\n\r" );
                return;
            }
        }
    }
    else
    {
        if ( is_number( pArgs ) != TRUE )
        {
            write_string_buffer( pTerm, "Usage: new [number]\n\r" );
            return;
        }

        iNumber = atoi( pArgs );

        if ( iNumber <= 5 || iNumber > MAX_INDEX_NUMBER )
        {
            snprintf( cBuf, 128, "Number must be between 5 and %d.\n\r",
              MAX_INDEX_NUMBER );
            write_string_buffer( pTerm, cBuf );
            return;
        }
    }

    pNewRoomIndex                 = alloc_mem( sizeof( *pNewRoomIndex ) );
    pNewRoomIndex->iNumber        = iNumber;

    for ( i = 0; i < 10; i++ )
    {
        pNewRoomIndex->sDirDescs[i]            = EMPTY_STRING;
        pNewRoomIndex->eExits[i].pDoorNames    = alloc_mem( ( sizeof(
                                                   string ) * 2 ) );
        pNewRoomIndex->eExits[i].pDoorNames[0] = EMPTY_STRING;
        pNewRoomIndex->eExits[i].pDoorNames[1] = NULL;
        pNewRoomIndex->eExits[i].sFound        = EMPTY_STRING;
    }

    pNewRoomIndex->sImageFilename = EMPTY_STRING;
    pNewRoomIndex->sTitle         = save_string( "(no title)" );
    pNewRoomIndex->sDesc          = save_string( "(no description)" );
    pNewRoomIndex->iSectorType    = snSectorTable[0].iNumber;
    pNewRoomIndex->iTemperature   = 60;

    iNumber                      %= iHashListSize;
    pNewRoomIndex->pNext          = ppRoomIndexList[iNumber];
    ppRoomIndexList[iNumber]      = pNewRoomIndex;

    pTerm->uEdit.pEditRoom        = pNewRoomIndex;

    pNewRoomIndex->bNew           = TRUE;
    pNewRoomIndex->bEdited        = TRUE;

    sprintf( cBuf, "Created new room with number: %d.\n\r", iNumber );
    write_string_buffer( pTerm, cBuf );
}


void olc_cmd_room_save( TERM_DATA *pTerm, char *pArgs )
{
    ROOM_INDEX_DATA *pRoom;
    char cBuf[MAX_STRING];
    int i;

    if ( pArgs[0] == '\0' )
    {
        if ( ( pRoom = pTerm->uEdit.pEditRoom ) == NULL )
        {
            write_string_buffer( pTerm, "You must be editing a room to "
              "use this command with no arguments.\n\r" );
            return;
        }

        snprintf( cBuf, MAX_STRING, "%s/%ld.room", pRoomDir,
          pRoom->iNumber );

        if ( save_room( pRoom, cBuf ) == TRUE )
            write_string_buffer( pTerm, "Room saved.\n\r" );
        else
        {
            write_string_buffer( pTerm, "Room could not be saved.\n\r" );
            sap_warning( "Could not save room to file `%s'.", cBuf );
        }

        return;
    }
    else if ( str_compare( pArgs, "all" ) == TRUE )
    {
        for ( i = 0; i < iHashListSize; i++ )
        {
            for ( pRoom = ppRoomIndexList[i]; pRoom; pRoom = pRoom->pNext )
            {
                snprintf( cBuf, MAX_STRING, "%s/%ld.room", pRoomDir,
                  pRoom->iNumber );
                save_room( pRoom, cBuf );
            }
        }

        write_string_buffer( pTerm, "All rooms saved.\n\r" );
        return;
    }
    else if ( is_number( pArgs ) == TRUE )
    {
        if ( ( pRoom = get_room_index( atol( pArgs ) ) ) == NULL )
        {
            write_string_buffer( pTerm, "No such room.\n\r" );
            return;
        }

        snprintf( cBuf, MAX_STRING, "%s/%ld.room", pRoomDir,
          pRoom->iNumber );

        if ( save_room( pRoom, cBuf ) == TRUE )
            write_string_buffer( pTerm, "Room saved.\n\r" );
        else
        {
            write_string_buffer( pTerm, "Room could not be saved.\n\r" );
            sap_warning( "Could not save room to file `%s'.", cBuf );
        }

        return;
    }

    write_string_buffer( pTerm, "Usage: save [number|\"all\"]\n\r" );
}


void olc_cmd_room_list( TERM_DATA *pTerm, char *pArgs )
{
    int i;

    if ( pArgs[0] == '\0' )
        goto usage;

    if ( str_prefix( pArgs, "sectors" ) == TRUE )
    {
        for ( i = 0; snSectorTable[i].pName[0] != '\0'; i++ )
        {
            write_string_buffer( pTerm, snSectorTable[i].pName );
            write_string_buffer( pTerm, "\n\r" );
        }

        return;
    }
    else if ( str_prefix( pArgs, "flags" ) == TRUE )
    {
        for ( i = 0; snRoomFlagsTable[i].pName[0] != '\0'; i++ )
        {
            write_string_buffer( pTerm,
              uncapit( snRoomFlagsTable[i].pName ) );
            write_string_buffer( pTerm, "\n\r" );
        }

        return;
    }
    else if ( str_prefix( pArgs, "doorflags" ) == TRUE )
    {
        write_string_buffer( pTerm,
          "closed\n\r"
          "locked\n\r"
          "hidden\n\r"
          "level <number>\n\r"
          "key <number>\n\r" );
        return;
    }

usage:
    write_string_buffer( pTerm,
      "Usage: list <\"sectors\"|\"flags\"|\"doorflags\">\n\r" );
}


void olc_cmd_room_title( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->uEdit.pEditRoom == NULL )
    {
        write_string_buffer( pTerm,
          "You must be editing a room to use this command.\n\r" );
        return;
    }

    free_string( &pTerm->uEdit.pEditRoom->sTitle );
    pTerm->uEdit.pEditRoom->sTitle = save_string( pArgs );

    write_string_buffer( pTerm, "Room title set.\n\r" );
}


void olc_cmd_room_description( TERM_DATA *pTerm, char *pArgs )
{
    if ( pTerm->uEdit.pEditRoom == NULL )
    {
        write_string_buffer( pTerm,
          "You must be editing a room to use this command.\n\r" );
        return;
    }

    setup_text_editor( pTerm, &pTerm->uEdit.pEditRoom->sDesc, FALSE );
}


void olc_cmd_room_sector( TERM_DATA *pTerm, char *pArgs )
{
    int i;

    if ( pTerm->uEdit.pEditRoom == NULL )
    {
        write_string_buffer( pTerm,
          "You must be editing a room to use this command.\n\r" );
        return;
    }

    if ( pArgs[0] == '\0' )
    {
        write_string_buffer( pTerm, "Usage: sector <flag>\n\r" );
        return;
    }

    for ( i = 0; snSectorTable[i].pName[0] != '\0'; i++ )
    {
        if ( str_compare( pArgs, snSectorTable[i].pName ) == TRUE )
            break;
    }

    if ( snSectorTable[i].pName[0] == '\0' )
    {
        write_string_buffer( pTerm, "No such sector type.\n\r" );
        return;
    }

    pTerm->uEdit.pEditRoom->iSectorType = snSectorTable[i].iNumber;
    write_string_buffer( pTerm, "Sector type set.\n\r" );
}


void olc_cmd_room_flag( TERM_DATA *pTerm, char *pArgs )
{
    ROOM_INDEX_DATA *pRoom;
    int i;

    if ( ( pRoom = pTerm->uEdit.pEditRoom ) == NULL )
    {
        write_string_buffer( pTerm,
          "You must be editing a room to use this command.\n\r" );
        return;
    }

    if ( pArgs[0] == '\0' )
    {
        write_string_buffer( pTerm, "Usage: flag <flag>\n\r" );
        return;
    }

    for ( i = 0; snRoomFlagsTable[i].pName[0] != '\0'; i++ )
    {
        if ( str_compare( pArgs, snRoomFlagsTable[i].pName ) == TRUE )
            break;
    }

    if ( snRoomFlagsTable[i].pName[0] == '\0' )
    {
        write_string_buffer( pTerm, "No such room flag.\n\r" );
        return;
    }

    if ( IS_SET( pRoom->fRoomFlags, snRoomFlagsTable[i].iNumber ) )
    {
        REMOVE_FLAG( pRoom->fRoomFlags, snRoomFlagsTable[i].iNumber );
        write_string_buffer( pTerm, "Flag toggled off.\n\r" );
    }
    else
    {
        SET_FLAG( pRoom->fRoomFlags, snRoomFlagsTable[i].iNumber );
        write_string_buffer( pTerm, "Flag toggled on.\n\r" );
    }
}


/*
 * End of olc_cmd.c
 */