/**
 **	Server.cc - Server functions for Exult (NOT ExultStudio).
 **
 **	Written: 5/2/2001 - JSF
 **/

/*
Copyright (C) 2000-2002 The Exult Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>	// All the ifdefs aren't useful if we don't do this
#endif

// only if compiled with "exult studio support"
#ifdef USE_EXULTSTUDIO

#include <unistd.h>
#include <fcntl.h>

#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif

#if HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif

#include <cstdio>

#ifdef _AIX
#include <strings.h>
#endif

#if HAVE_NETDB_H
#include <netdb.h>
#endif

#ifndef WIN32
#include <sys/un.h>
#endif

#include "server.h"
#include "servemsg.h"
#include "utils.h"
#include "egg.h"
#include "actors.h"
#include "gamewin.h"
#include "gamemap.h"
#include "chunkter.h"
#include "cheat.h"
#include "objserial.h"
#include "effects.h"

#ifdef USECODE_DEBUGGER
#include "debugserver.h"
#endif

#ifdef WIN32
#include "servewin32.h"
#include "cheat.h"
#endif

using std::cout;
using std::cerr;
using std::endl;
/*
 *	Sockets, etc.
 */
extern int xfd;				// X-windows fd.
int listen_socket = -1;			// Listen here for map-editor.
int client_socket = -1;			// Socket to the map-editor.
int highest_fd = -1;			// Largest fd + 1.

#ifdef __sun__
// Solaris doesn't know PF_LOCAL
#define PF_LOCAL PF_UNIX
#endif

/*
 *	Set the 'highest_fd' value to 1 + <largest fd>.
 */
inline void Set_highest_fd
	(
	)
	{
	highest_fd = xfd;		// Figure highest to listen to.
	if (listen_socket > highest_fd)
		highest_fd = listen_socket;
	if (client_socket > highest_fd)
		highest_fd = client_socket;
	highest_fd++;			// Select wants 1+highest.
	}

/*
 *	Initialize server for map-editing.  Call this AFTER xfd has been set.
 */

void Server_init
	(
	)
	{
#ifndef WIN32
	// Get location of socket file.
	std::string servename("");
	char *home = getenv("HOME");
	if (home)			// Use $HOME/.exult/exultserver
		{			//   if possible.
		servename = home;
		servename += "/.exult";
		if (U7exists(servename.c_str()))
			servename += "/exultserver";
		else
			servename = "";
		}
	if (servename == "")
		servename = get_system_path("<GAMEDAT>/exultserver");
	// Make sure it isn't there.
	unlink(servename.c_str());
#if HAVE_GETADDRINFOX
	// Don't use the old deprecated network API
	int r;
	struct addrinfo hints,*ai;

	memset(&hints,0,sizeof(hints));
	hints.ai_flags=AI_PASSIVE;
	r=getaddrinfo(	0,
			servename.c_str(),
			&hints,
			&ai);
	if(r!=0)
		{
		cerr << "getaddrinfo(): "<<gai_strerror(r) << endl;
		return;
		}

	listen_socket = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
#else
	// Deprecated
	listen_socket = socket(PF_LOCAL, SOCK_STREAM, 0);
#endif
	if (listen_socket < 0)
		perror("Failed to open map-editor socket");
	else 
		{
#if HAVE_GETADDRINFOX
		if(bind(listen_socket,ai->ai_addr,ai->ai_addrlen) == -1 ||
			listen(listen_socket,1) == -1)
#else
		struct sockaddr_un addr;
		addr.sun_family = AF_UNIX;
		strcpy(addr.sun_path, servename.c_str());
		if (bind(listen_socket, (struct sockaddr *) &addr, 
		      sizeof(addr.sun_family) + strlen(addr.sun_path)) == -1 ||
		    listen(listen_socket, 1) == -1)
#endif
			{
			perror("Bind or listen on socket failed");
			close(listen_socket);
			listen_socket = -1;
			}
		else			// Set to be non-blocking.
			{
			cout << "Listening on socket " << listen_socket
								<< endl;
			fcntl(listen_socket, F_SETFL, 
				fcntl(listen_socket, F_GETFL) | O_NONBLOCK);
			}
#if HAVE_GETADDRINFOX
		freeaddrinfo(ai);
#endif
		}
	Set_highest_fd();
#else

	listen_socket = client_socket = -1;

	std::string servename = get_system_path("<STATIC>");

	if (Exult_server::create_pipe(servename.c_str())) listen_socket = 1;

#endif
	}

/*
 *	Close the server.
 */

void Server_close
	(
	)
	{
#ifdef WIN32
	Exult_server::close_pipe();
	listen_socket = client_socket = -1;
#else
	// unlink socket file+++++++
#endif
	}


/*
 *	A message from a client is available, so handle it.
 */

static void Handle_client_message
	(
	int& fd				// Socket to client.  May be closed.
	)
	{
	unsigned char data[Exult_server::maxlength];
	Exult_server::Msg_type id;
	int datalen = Exult_server::Receive_data(fd, id, data, sizeof(data));
	if (datalen < 0)
		return;
	unsigned char *ptr = &data[0];
	Game_window *gwin = Game_window::get_instance();
	switch (id)
		{
	case Exult_server::obj:
		Game_object::update_from_studio(&data[0], datalen);
		break;
	case Exult_server::egg:
		Egg_object::update_from_studio(&data[0], datalen);
		break;
	case Exult_server::npc:
		Actor::update_from_studio(&data[0], datalen);
		break;
	case Exult_server::info:
		{
		unsigned char data[Exult_server::maxlength];
		unsigned char *ptr = &data[0];
		Game_info_out(client_socket, Exult_server::version, 
			cheat.get_edit_lift(),
			gwin->skip_lift,
			cheat.in_map_editor(),
			cheat.show_tile_grid(),
			gwin->get_map()->was_map_modified(),
			(int) cheat.get_edit_mode());
		break;
		}
	case Exult_server::write_map:
		gwin->write_map();	// Send feedback?+++++
		break;
	case Exult_server::read_map:
		gwin->read_map();
		break;
	case Exult_server::map_editing_mode:
		{
		int onoff = Read2(ptr);
		if ((onoff != 0) != cheat.in_map_editor())
			cheat.toggle_map_editor();
		break;
		}
	case Exult_server::tile_grid:
		{
		int onoff = Read2(ptr);
		if ((onoff != 0) != cheat.show_tile_grid())
			cheat.toggle_tile_grid();
		break;
		}
	case Exult_server::edit_lift:
		{
		int lift = Read2(ptr);
		cheat.set_edit_lift(lift);
		break;
		}
	case Exult_server::reload_usecode:
		gwin->reload_usecode();
		break;
	case Exult_server::locate_terrain:
		{
		int tnum = Read2(ptr);
		int cx = (short) Read2(ptr);
		int cy = (short) Read2(ptr);
		bool up = *ptr++ ? true : false;
		bool okay = gwin->get_map()->locate_terrain(tnum, cx, cy, up);
		ptr = &data[2];		// Set back reply.
		Write2(ptr, cx);
		Write2(ptr, cy);
		ptr++;			// Skip 'up' flag.
		*ptr++ = okay ? 1 : 0;
		Exult_server::Send_data(client_socket, 
			Exult_server::locate_terrain, data, ptr - data);
		break;
		}
	case Exult_server::swap_terrain:
		{
		int tnum = Read2(ptr);
		bool okay = gwin->get_map()->swap_terrains(tnum);
		*ptr++ = okay ? 1 : 0;
		Exult_server::Send_data(client_socket,
			Exult_server::swap_terrain, data, ptr - data);
		break;
		}
	case Exult_server::insert_terrain:
		{
		int tnum = (short) Read2(ptr);
		bool dup = *ptr++ ? true : false;
		bool okay = gwin->get_map()->insert_terrain(tnum, dup);
		*ptr++ = okay ? 1 : 0;
		Exult_server::Send_data(client_socket, 
			Exult_server::insert_terrain, data, ptr - data);
		break;
		}
	case Exult_server::delete_terrain:
		{
		int tnum = (short) Read2(ptr);
		bool okay = gwin->get_map()->delete_terrain(tnum);
		*ptr++ = okay ? 1 : 0;
		Exult_server::Send_data(client_socket,
			Exult_server::delete_terrain, data, ptr - data);
		break;
		}
	case Exult_server::send_terrain:
		{			// Send back #, total, 512-bytes data.
		int tnum = (short) Read2(ptr);
		Write2(ptr, gwin->get_map()->get_num_chunk_terrains());
		Chunk_terrain *ter = gwin->get_map()->get_terrain(tnum);
		ter->write_flats(ptr);	// Serialize it.
		ptr += 512;		// I just happen to know the length...
		Exult_server::Send_data(client_socket, 
			Exult_server::send_terrain, data, ptr - data);
		break;
		}
	case Exult_server::terrain_editing_mode:
		{			// 1=on, 0=off, -1=undo.
		int onoff = (short) Read2(ptr);
					// skip_lift==0 <==> terrain-editing.
		gwin->skip_lift = onoff == 1 ? 0 : 16;
		static char *msgs[3] = {"Terrain-Editing Aborted",
					"Terrain-Editing Done",
					"Terrain-Editing Enabled"};
		if (onoff == 0)		// End/commit.
			gwin->get_map()->commit_terrain_edits();
		else if (onoff == -1)
			gwin->get_map()->abort_terrain_edits();
		if (onoff >= -1 && onoff <= 1)
			gwin->get_effects()->center_text(msgs[onoff + 1]);
		gwin->set_all_dirty();
		break;
		}
	case Exult_server::set_edit_shape:
		{
		int shnum = (short) Read2(ptr);
		int frnum = (short) Read2(ptr);
		cheat.set_edit_shape(shnum, frnum);
		break;
		}
	case Exult_server::view_pos:
		{
		int tx = Read4(ptr);
		if (tx == -1)		// This is a query?
			{
			gwin->send_location();
			break;
			}
		int ty = Read4(ptr);
		// +++Later int txs = Read4(ptr);
		// int tys = Read4(ptr);
		// int scale = Read4(ptr);
					// Only set if chunk changed.
		if (tx/c_tiles_per_chunk != 
			gwin->get_scrolltx()/c_tiles_per_chunk || 
		    ty/c_tiles_per_chunk != 
			gwin->get_scrollty()/c_tiles_per_chunk)
			{
			gwin->set_scrolls(tx, ty);
			gwin->set_all_dirty();
			}
		break;
		}
	case Exult_server::set_edit_mode:
		{
		int md = Read2(ptr);
		if (md >= 0 && md <= 3)
			cheat.set_edit_mode((Cheat::Map_editor_mode) md);
		break;
		}
	case Exult_server::hide_lift:
		{
		int lift = Read2(ptr);
		gwin->skip_lift = lift;
		gwin->set_all_dirty();
		break;
		}
	case Exult_server::reload_shapes:
		Shape_manager::get_instance()->reload_shapes(Read2(ptr));
		break;
	case Exult_server::unused_shapes:
		{			// Send back shapes not used in game.
		unsigned char data[Exult_server::maxlength];
		int sz = 1024/8;	// Gets bits for unused shapes.
		sz = sz > sizeof(data) ? sizeof(data) : sz;
		gwin->get_map()->find_unused_shapes(data, sz);
		Exult_server::Send_data(client_socket, 
				Exult_server::unused_shapes, data, sz);
		break;
		}
	case Exult_server::locate_shape:
		{
		int shnum = Read2(ptr);
		bool up = *ptr++ ? true : false;
		bool okay = gwin->locate_shape(shnum, up);
		ptr = &data[2];		// Send back reply.
		ptr++;			// Skip 'up' flag.
		*ptr++ = okay ? 1 : 0;
		Exult_server::Send_data(client_socket, 
			Exult_server::locate_shape, data, ptr - data);
		break;
		}
	case Exult_server::cut:		// Cut/copy.
		cheat.cut(*ptr != 0);
		break;
	case Exult_server::paste:
		cheat.paste();
		break;
	case Exult_server::npc_info:
		Write2(ptr, gwin->get_num_npcs());
		Write2(ptr, gwin->get_unused_npc());
		Exult_server::Send_data(client_socket, Exult_server::npc_info,
							data, ptr - data);
		break;
	case Exult_server::edit_selected:
		{
		unsigned char basic = *ptr;
		const Game_object_vector& sel = cheat.get_selected();
		if (!sel.empty())
			if (basic)		// Basic obj. props?
				sel.back()->Game_object::edit();
			else
				sel.back()->edit();
		break;
		}
	case Exult_server::set_edit_chunknum:
		cheat.set_edit_chunknum((short) Read2(ptr));
		break;

	case Exult_server::game_pos:
		{
		Tile_coord pos = gwin->get_main_actor()->get_tile();
		Write2(ptr, pos.tx);
		Write2(ptr, pos.ty);
		Write2(ptr, pos.tz);
		Exult_server::Send_data(client_socket, 
			Exult_server::game_pos, data, ptr - data);
		break;
		}

#ifdef USECODE_DEBUGGER
	case Exult_server::usecode_debugging:
		Handle_debug_message(&data[0], datalen);
		break;
#endif
		}
	}

/*
 *	Delay for a fraction of a second, or until there's data available.
 *	If a server request comes, it's handled here.
 */

void Server_delay
	(
	 Message_handler handle_message
	)
	{
#ifndef WIN32
	extern int xfd;
	fd_set rfds;
	struct timeval timer;
	timer.tv_sec = 0;
	timer.tv_usec = 50000;		// Try 1/50 second.
	FD_ZERO(&rfds);
	FD_SET(xfd, &rfds);
	if (listen_socket >= 0)
		FD_SET(listen_socket, &rfds);
	if (client_socket >= 0)
		FD_SET(client_socket, &rfds);
					// Wait for timeout or event.
	if (select(highest_fd, &rfds, 0, 0, &timer) > 0)
		{			// Something's come in.
		if (listen_socket >= 0 && FD_ISSET(listen_socket, &rfds))
			{		// New client connection.
					// For now, just one at a time.
			if (client_socket >= 0)
				close(client_socket);
			client_socket = accept(listen_socket, 0, 0);
			cout << "Accept returned client_socket = " <<
							client_socket << endl;
					// Non-blocking.
			fcntl(client_socket, F_SETFL, 
				fcntl(client_socket, F_GETFL) | O_NONBLOCK);
			Set_highest_fd();
			}
		if (client_socket >= 0 && FD_ISSET(client_socket, &rfds))
			{
			handle_message(client_socket);
					// Client gone?
			if (client_socket == -1)
				Set_highest_fd();
			}
		}
#else
	if (listen_socket == -1) return;

	if (Exult_server::is_broken()) {
		std::cout << "Client disconnected." << endl;
		Exult_server::disconnect_from_client();
		Exult_server::setup_connect();
		client_socket = -1;
	}

	SleepEx(20, TRUE);

	if (client_socket == -1) {
		// Only do this in map edit mode
		if (!cheat.in_map_editor()) return;

		std::string servename = get_system_path("<STATIC>");
		if (!Exult_server::try_connect_to_client(servename.c_str())) return;
		else client_socket = 1;
		std::cout << "Connected to client" << endl;
	}

	if (Exult_server::peek_pipe() > 0)
		handle_message(client_socket);
		
	if (Exult_server::is_broken()) {
		if (Exult_server::notify_connection_lost()) std::cout << "Client disconnected." << endl;
		Exult_server::disconnect_from_client();
		Exult_server::setup_connect();
		client_socket = -1;
	}
#endif

	}

void Server_delay()
{
	Server_delay(Handle_client_message);
}

#endif