#include <common/openfile.hpp>
#include <common/filemap.hpp>
#include <common/pview.hpp>
#include <common/diskinfo.hpp>
#include <common/systime.hpp>
#include <ftp/interprt.hpp>
#include <ftp/logindlg.hpp>
#include <ftp/ftpdata.hpp>

FTPInterpreter::FTPInterpreter(void)
: mlpEditMonitor(0), mNotConnected("Not connected."), mNotLoggedIn("Not logged in.")
{
  symbolLoad();
}

void FTPInterpreter::setText(Block<String> &messageStrings)
{
  for(short itemIndex=0;itemIndex<messageStrings.size();itemIndex++)setText(messageStrings[itemIndex]);
}

void FTPInterpreter::interpretLine(const String &lineString)
{
	if(lineString.isNull())return;
	FileMap srcMap("SRCMAP",0L,lineString.length());
	PureViewOfFile pureView(srcMap);
	pureView.write(lineString);
	interpret(srcMap);
}

void FTPInterpreter::interpretFile(const String &pathFileName)
{
	FileHandle srcFile(pathFileName,FileHandle::Read,FileHandle::ShareRead);
	FileMap srcMap(srcFile);
  interpret(srcMap);
}

void FTPInterpreter::interpret(FileMap &srcMap)
{
	DWORD asmLength;
	FileMap dstMap("DSTMAP",0,250000,FileMap::ReadWrite,FileMap::Commit);
	FileMap asmMap("ASMMAP",0,250000,FileMap::ReadWrite,FileMap::Commit);
	PureViewOfFile srcView(srcMap);
	PureViewOfFile dstView(dstMap);
	Scan scriptScan(srcView,dstView,mSymbolTable);

	scriptScan.analyze();
	dstView.rewind();
	PureViewOfFile asmView(asmMap);
	Parse scriptParse(dstView,asmView);
	scriptParse.parse();
	asmLength=asmView.tell();
	asmView.destroyView();
	asmView.createView(asmMap,0L,0L,asmLength);
	if(Parse::Ok!=scriptParse.status())
	{
		String errorInfo;
		::sprintf(errorInfo,"syntax error at line #%d",scriptParse.lastLineNumber());
		setText(errorInfo);
		return;
	}
	assemble(asmView);
}

void FTPInterpreter::openHandler(const String &hostName)
{
	LoginDialog loginDialog;

	if(!open(hostName))return;
	loginDialog.performLogin();
	if(loginDialog.userName().isNull())return;
	if(loginDialog.password().isNull())return;
  login(loginDialog.userName(),loginDialog.password());
}

void FTPInterpreter::openHandler(const String &hostName,const String &userName,const String &password)
{
	if(!open(hostName))return;
	login(userName,password);
}

void FTPInterpreter::closeHandler(void)
{
  logout();
}

void FTPInterpreter::userHandler(const String &userName)
{
	LoginDialog loginDialog;

	if(!isConnected()){setText(mNotConnected);return;}
	loginDialog.userName(userName);
	loginDialog.performLogin();
	if(loginDialog.userName().isNull())return;
	if(loginDialog.password().isNull())return;
  login(loginDialog.userName(),loginDialog.password());
}

void FTPInterpreter::pwdHandler(void)
{
	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn())return;
	printWorkingDirectory();
}

void FTPInterpreter::cdHandler(const String &pathDirectory)
{
	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
  changeWorkingDirectory(pathDirectory);
}

void FTPInterpreter::lcdHandler(const String &pathDirectory)
{
	String currentDirectory;
  String prefixString("Current directory is: ");
	DiskInfo diskInfo;
	if(pathDirectory.isNull())
	{
		diskInfo.getCurrentDirectory(currentDirectory);
    setText(prefixString+currentDirectory);
  }
	else
	{
		diskInfo.setCurrentDirectory(pathDirectory);
		diskInfo.getCurrentDirectory(currentDirectory);
    setText(prefixString+currentDirectory);
  }
}

void FTPInterpreter::disconnectHandler(void)
{
  logout();
}

void FTPInterpreter::byeHandler(void)
{
  logout();
}

void FTPInterpreter::quitHandler(void)
{
	if(isConnected())logout();
	SystemTime systemTime;
	setText(String("client stopped on ")+systemTime.toString());
	::Sleep(500L);
}

void FTPInterpreter::remotehelpHandler(const String &remoteHelpTopic)
{
	help(remoteHelpTopic);
}

void FTPInterpreter::renameHandler(const String &oldPathFileName,const String &newPathFileName)
{
  if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
  if(oldPathFileName.isNull()||newPathFileName.isNull())return;
	if(!renameFrom(oldPathFileName))return;
  if(!renameTo(newPathFileName))return;
}

void FTPInterpreter::asciiHandler(void)
{
	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	type('A');
}

void FTPInterpreter::binaryHandler(void)
{
	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	type('I');
}

void FTPInterpreter::deleteHandler(const String &pathFileName)
{
	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	if(pathFileName.isNull())return;
	remove(pathFileName);
}

void FTPInterpreter::mdeleteHandler(const String &paramString)
{
	FTPData ftpData;
	String lineString;
	Block<String> nameStrings;

	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	if(!port(ftpData))return;
	if(!nameList(paramString,FALSE))return;
  if(!ftpData.accept())return;
	while(ftpData.receive(lineString))nameStrings.insert(&lineString);
	ftpData.destroy();
	if(receive(lineString))setText(lineString);
  for(DWORD itemIndex=0;itemIndex<nameStrings.size();itemIndex++)deleteHandler(nameStrings[itemIndex]);
}

void FTPInterpreter::dirHandler(const String &paramString)
{
	FTPData ftpData;
	String lineString;

	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	if(!port(ftpData))return;
	if(!list(paramString))return;
	if(!ftpData.accept())return;
	while(ftpData.receive(lineString))setText(lineString);
  ftpData.destroy();
	if(receive(lineString))setText(lineString);
}

void FTPInterpreter::lsHandler(const String &paramString)
{
	FTPData ftpData;
	String lineString;

	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	if(!port(ftpData))return;
	if(!nameList(paramString))return;
	if(!ftpData.accept())return;
	while(ftpData.receive(lineString))setText(lineString);
	ftpData.destroy();
	if(receive(lineString))setText(lineString);
}

void FTPInterpreter::getHandler(const String &pathFileName)
{
	FTPData ftpData;
	TimeInfo timeInfo;
	String lineString;
	String remoteFileName;
	DWORD sizeData;

	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	if(!port(ftpData))return;
  if(!retrieve(pathFileName,sizeData))return;
	if(!ftpData.accept())return;
	if(currentType()=='A')while(ftpData.receive(lineString))setText(lineString);
	else
	{
    if(!sizeData)ftpData.receiveBinary(pathFileName,timeInfo);
    else ftpData.receiveBinary(pathFileName,sizeData,timeInfo);
	}
	ftpData.destroy();
	if(receive(lineString))setText(lineString);
	setText((String)timeInfo);
}

void FTPInterpreter::mgetHandler(const String &paramString)
{
	FTPData ftpData;
	String lineString;
	Block<String> nameStrings;

	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	if(!port(ftpData))return;
	if(!nameList(paramString,FALSE))return;
	if(!ftpData.accept())return;
	while(ftpData.receive(lineString))nameStrings.insert(&lineString);
	ftpData.destroy();
	if(receive(lineString))setText(lineString);
	for(DWORD itemIndex=0;itemIndex<nameStrings.size();itemIndex++)getHandler(nameStrings[itemIndex]);
}

void FTPInterpreter::sendHandler(const String &pathFileName)
{
	putHandler(pathFileName);
}

void FTPInterpreter::putHandler(const String &pathFileName)
{
	String responseString;
	FTPData ftpData;
	TimeInfo timeInfo;

	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	FileHandle sendFile(pathFileName,FileHandle::Read,FileHandle::ShareRead);
	if(!sendFile.isOkay()){setText("Error accessing local file.");return;}
	sendFile.close();
	if(!port(ftpData))return;
  if(!store(pathFileName))return;
	if(!ftpData.accept())return;
	ftpData.sendBinary(pathFileName,timeInfo);
	ftpData.destroy();
	if(receive(responseString))setText(responseString);
	setText((String)timeInfo);
}

void FTPInterpreter::mkdirHandler(const String &pathDirectory)
{
	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
	makeDirectory(pathDirectory);
}

void FTPInterpreter::rmdirHandler(const String &pathDirectory)
{
	if(!isConnected()){setText(mNotConnected);return;}
	if(!isLoggedIn()){setText(mNotLoggedIn);return;}
  removeDirectory(pathDirectory);
}

void FTPInterpreter::appendHandler(const String &localPathFileName,const String &remotePathFileName)
{
	setText(String("appendHandler")+String(localPathFileName+String("-")+remotePathFileName));
}

void FTPInterpreter::literalHandler(const String &literalString)
{
	setText(String("literalHandler")+literalString);
}

void FTPInterpreter::mdirHandler(const String &pathDirectory)
{
  setText(String("mdirHandler")+pathDirectory);
}

void FTPInterpreter::typeHandler(const String &paramString)
{
  setText(String("typeHandler")+paramString);
}

void FTPInterpreter::mlsHandler(const String &pathDirectory)
{
	setText(String("mlsHandler")+pathDirectory);
}

void FTPInterpreter::quoteHandler(const String &commandString)
{
	setText(String("quoteHandler")+commandString);
}

void FTPInterpreter::recvHandler(const String &pathFileName)
{
  setText(String("recvHandler")+pathFileName);
}

void FTPInterpreter::mputHandler(const String &pathFileName)
{
  setText(String("mputHandler")+pathFileName);
}

void FTPInterpreter::debugHandler(void)
{
	setText("debugHandler");
}

void FTPInterpreter::promptHandler(void)
{
	setText("promptHandler");
}

void FTPInterpreter::statusHandler(void)
{
	setText("statusHandler");
}

void FTPInterpreter::traceHandler(void)
{
	setText("traceHandler");
}

void FTPInterpreter::bellHandler(void)
{
	setText("bellHandler");
}

void FTPInterpreter::globHandler(void)
{
  setText("globHandler");
}

void FTPInterpreter::hashHandler(void)
{
  setText("hashHandler");
}

void FTPInterpreter::verboseHandler(void)
{
	setText("verboseHandler");
}

void FTPInterpreter::helpHandler(void)
{
	WORD symbolCount(mSymbolTable.size());

	for(short symbolIndex=0;symbolIndex<symbolCount;)
	{
    String helpStrings;
		for(short itemIndex=0;itemIndex<10&&symbolIndex<symbolCount;itemIndex++,symbolIndex++)
		{
			helpStrings+=mSymbolTable[symbolIndex].symbolName();
      helpStrings+=" ";
		}
    setText(helpStrings);
  }
}

void FTPInterpreter::symbolLoad(void)
{
  mSymbolTable.remove();
	mSymbolTable.insert(&Symbol(String("append"),Scan::append1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("ascii"),Scan::ascii1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("delete"),Scan::delete1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("debug"),Scan::debug1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("dir"),Scan::dir1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("disconnect"),Scan::disconnect1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("literal"),Scan::literal1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("ls"),Scan::ls1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("mdelete"),Scan::mdelete1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("mdir"),Scan::mdir1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("prompt"),Scan::prompt1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("put"),Scan::put1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("pwd"),Scan::pwd1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("quit"),Scan::quit1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("send"),Scan::send1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("status"),Scan::status1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("trace"),Scan::trace1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("type"),Scan::type1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("bell"),Scan::bell1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("binary"),Scan::binary1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("bye"),Scan::bye1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("get"),Scan::get1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("glob"),Scan::glob1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("hash"),Scan::hash1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("mget"),Scan::mget1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("mkdir"),Scan::mkdir1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("mls"),Scan::mls1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("quote"),Scan::quote1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("recv"),Scan::recv1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("remotehelp"),Scan::remotehelp1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("user"),Scan::user1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("verbose"),Scan::verbose1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("cd"),Scan::cd1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("help"),Scan::help1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("mput"),Scan::mput1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("rename"),Scan::rename1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("close"),Scan::close1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("lcd"),Scan::lcd1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("open"),Scan::open1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("rmdir"),Scan::rmdir1,Symbol::CommandSymbol));
	mSymbolTable.insert(&Symbol(String("sleep"),Scan::sleep1,Symbol::CommandSymbol));
}

// **** virtual overloads

void FTPInterpreter::message(const String &lineString)
{
  setText(lineString);
}

void FTPInterpreter::message(Block<String> &lineStrings)
{
  setText(lineStrings);
}