/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, either version 3 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 Lesser General Public License for more details.

* 

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <boost/program_options.hpp>

namespace po = boost::program_options;

#include <boost/regex.hpp>

#include <boost/filesystem.hpp>

namespace fs = boost::filesystem;

#include <iostream>

#include <iterator>

#include <string>

#include <map>

#include <set>

#include <ctype.h>

#include <cstdlib>

using namespace std;

#include "defs.h"

#include "romdetails.h"

#include "inputfile.h"

#include "elfromerror.h"

static inline void downcase(std::string & s){

	for (std::string::iterator i = s.begin(); i != s.end(); i++)

		*i = tolower(*i);

}

static int required_option(const po::variables_map& vm, const char* option){

	if (vm.count(option) == 0 || vm[option].defaulted()) {

		cerr << "Error: option \'" << option << "\' required.\n";

		return 1;

	} 

	return 0;

}

static int either_or_required(const po::variables_map& vm, const char* option1, const char* option2){

	if ((vm.count(option1) == 0 || vm[option1].defaulted()) &&

		(vm.count(option2) == 0 || vm[option2].defaulted())) {

		cerr << "Error: either option \'" << option1 << "\' or option \'" << option2 <<"\' required.\n";

		return 1;

	} 

	return 0;

}

RomDetails * ProcessOptions(int ac, char* av[]) {

	RomDetails * details = new RomDetails;

	int errors = 0;

    try {

    	string phys_addr;

        po::options_description desc("  Command Line Only");

        desc.add_options()

            ("help,h", "produce help message")

            ("config-file,c", po::value<string>(), 	"pathname of config file "

            													  	"(overrides default of elf4rom.cfg and value "

            														"of ELF4ROM_CFG_FILE environment variable)")

        ;

        po::options_description config("  Command Line and Configuration File");

        config.add_options()

            ("board-name,b", po::value<string>(&details->iBoardName), 	"name of board targeted e.g. versatilepb")

            ("debug,d", po::value< vector<string> >(&details->iTargetFiles)->multitoken()->composing(), 

																		"collect ELF and DWARF data from the listed files")

			("drive,D", po::value<string>(&details->iDrive), 			"drive on which to find ELF files")

			("exclude,e", po::value< vector<string> >(&details->iExcludeFiles)->multitoken()->composing(), 

																		"exclude collection of ELF and DWARF data from the listed files")

            ("input,i", po::value<string>(&details->iRomFile), 			"pathname of ROM image")

            ("logfile,l", po::value<string>(&details->iLogFile), 		"pathname of ROMBUILD log file")

            ("no-dwarf,n", po::bool_switch(&details->iNoDwarf), 		"suppress generatation of DWARF in output"

																		" (prevents source level debugging but saves time and space)")

            ("output,o", po::value<string>(&details->iElfRomFile), 		"pathname of output file")

            // lexical_cast doesn't understand <LinearAddress> even though its just a typedef

            // for unsigned int

            ("physical-address,p", po::value<string>(&phys_addr), 		"physical address of ROM on device. Overrides board-name")

            ("search,s", po::bool_switch(&details->iSearch), 			"search for ELF files in build directory if .sym file not "

            															"found in release directory")

            ("strip,S", po::bool_switch(&details->iStrip), 				"suppress generation of symbol table and DWARF in output"

																		" (useful to produce a 'loadable' ELF image for e.g. a simulator)")

			("trace,t", po::bool_switch(&details->iTrace), 				"switch on trace")

			;

        po::options_description cmdline_options;

        cmdline_options.add(desc).add(config);

        po::options_description config_file_options;

        config_file_options.add(config);

        po::variables_map vm; 

        //po::store(po::parse_command_line(ac, av, desc), vm);

        po::store(po::command_line_parser(ac, av).options(cmdline_options).run(), vm);

        char * cfgFile = "elf4rom.cfg";

        if (vm.count("config-file")) {

        	char * xcfgFile = (char *)(vm["config-file"].as<string>().c_str());

        	fs::path cfgpath(xcfgFile);

        	if (fs::exists(cfgpath)) {

        		cfgFile = xcfgFile;

        	} else {

        		cerr << "Warning: specified config file " << xcfgFile << " not found: will not attempt to use default.\n";

        	}

        } else {

        	char * envCfgFile = getenv("ELF4ROM_CFG_FILE");

        	if (envCfgFile != NULL) 

        		cfgFile = envCfgFile;

        }

        ifstream ifs(cfgFile);

        store(parse_config_file(ifs, config_file_options), vm);

       	po::notify(vm); 

        if (vm.count("help")) {

        	cout << "elf4rom [option]";

            cout << cmdline_options << "\n";

            delete details;

            exit(EXIT_SUCCESS) ;

        }

        errors += required_option(vm, "input");

        errors += required_option(vm, "logfile");

        errors += required_option(vm, "output");

        errors += either_or_required(vm, "board-name", "physical-address");

        if (vm.count("physical-address")){

        	char *f;

        	const char * p = phys_addr.c_str();

        	details->iRomPhysAddr = strtoul(p ,&f , 16);

        	if (f == p){

        		cerr << "Error: invalid arg to --physical-address: " << phys_addr.c_str() << "\n";

        		exit(EXIT_FAILURE);

        	}

        } else if (vm.count("board-name")){

        	// TODO: figure out address frmo board name

        	cerr << "Error: --board-name option not implemented yet\n";

            exit(EXIT_FAILURE) ;

        }

        if (errors) {

        	cerr << "elf4rom [option]";

            cerr << cmdline_options << "\n";

            delete details;

            exit(EXIT_FAILURE) ;

        }

    }

    catch(exception& e) {

        cerr << "error: " << e.what() << "\n";

        exit(EXIT_FAILURE) ;

    }

    catch(...) {

        cerr << "Exception of unknown type!\n";

        exit(EXIT_FAILURE) ;

    }

    return details;

}

static bool VerifyLogFile(string::const_iterator & start, string::const_iterator & end, string::const_iterator & rest){

#if 0 

// Look for somthing like the following

ROMBUILD - Rom builder V2.08 (Build 593)

Copyright (c) 1996-2007 Symbian Software Ltd.

or

ROMBUILD - Rom builder V2.08 (Build 596)

Copyright (c) 1996-2009 Nokia Corporation.

#endif	

	const char * banner  = "ROMBUILD.*Rom builder.*Copyright.*";

	boost::regex e(banner);

	boost::match_results<string::const_iterator> what;

	if (boost::regex_search(start, end, what, e)){ 

		rest = what[0].second;

		return true;

	}

	return false;

}

static void OffenceWarning (string & offender){

	cerr << "Warning: The following section of the ROM Log appears corrupt:\n" << offender << "\n";	

}

static inline unsigned int ConvertToUnsignedLong(string & s, string & offender){

	char * endp;

	const char * ss = s.c_str();

	unsigned int res = strtoul(ss, &endp,16);

	if (endp == ss)

		OffenceWarning(offender);

	return res;

}

static bool ProcessXIPFile(string::const_iterator & start, string::const_iterator & end, 

		string::const_iterator & rest, RomDetails * details){

	const char * f  = 

		"Processing file (\\S+)\\s*" 		// 1

		"(\\[Primary\\]\\s*)?"				// 2

		"(\\[Secondary\\]\\s*)?"			// 3		

		"(ELF File:\\s*\\S+\\s*)?" 			// 4

		"(ELF MD5:\\s*\\S+\\s*)?"			// 5

		"Load Address:\\s+(\\S+)\\s*"		// 6

		"Size:\\s+\\S+\\s*"

		"Uids:\\s+\\S+\\s+\\S+\\s+\\S+\\s+\\S+\\s*"

		"Entry point:\\s+\\S+\\s*"

		"Code start addr:\\s+(\\S+)\\s*"	// 7

		"Data start addr:\\s+(\\S+)\\s*"	// 8

		"DataBssLinearBase:\\s+(\\S+)\\s*"	// 9

		"Text size:\\s+\\S+\\s*"

		"Code size:\\s+(\\S+)\\s*"			// 10

		"Data size:\\s+(\\S+)\\s*"			// 11

		"BssSize:\\s+(\\S+)\\s*"			// 12

		;

	boost::regex e(f);

	boost::match_results<string::const_iterator> what;

	if (boost::regex_search(start, end, what, e)){

		string filename(what[1].first, what[1].second);

		string offender(what[0].first, what[0].second);

		if (filename.size() == 0)

			OffenceWarning(offender);

		bool primary = what[2].matched;

		if (what[2].matched){

			primary = true;

		}

		const int kla = 6;

		string ls(what[kla].first, what[kla].second);

		LinearAddr load = ConvertToUnsignedLong(ls, offender);

		const int kta = kla + 1;

		string ts(what[kta].first, what[kta].second);

		LinearAddr text = ConvertToUnsignedLong(ts, offender);

		const int kda = kta + 1;

		string ds(what[kda].first, what[kda].second);

		LinearAddr data = ConvertToUnsignedLong(ds, offender);

		const int kva = kda + 1;

		string vds(what[kva].first, what[kva].second);

		VirtualAddr vdata = ConvertToUnsignedLong(vds, offender);

		const int kts = kva + 1;

		string tss(what[kts].first, what[kts].second);

		size_t textSize = ConvertToUnsignedLong(tss, offender);		

		const int kds = kts + 1;

		string dss(what[kds].first, what[kds].second);

		size_t fileDataSize = ConvertToUnsignedLong(dss, offender);

		const int kbs = kds + 1;

		string bsss(what[kbs].first, what[kbs].second);

		size_t bssSize = ConvertToUnsignedLong(bsss, offender);		

		VirtualAddr bss = vdata + fileDataSize;

		size_t memDataSize = fileDataSize + bssSize;

		string elffile("");

		details->iXIPFiles.push_back(XIPFileDetails(filename, 

													elffile, 

													load, 

													text, 

													textSize,

													vdata, 

													fileDataSize, 

													data, 

													bss, 

													memDataSize));

		if (primary)

			new(&details->iPrimary)XIPFileDetails(filename, 

												  elffile, 

												  load, 

												  text, 

												  textSize,

												  vdata, 

												  fileDataSize, 

												  data, 

												  bss, 

												  memDataSize);

		rest = what[0].second;

		return true;

	}

	rest = start;

	return false;

}

static void CheckXIPFiles(RomDetails * details, std::vector<string> & list){

	for (std::vector<string>::iterator i = list.begin(); i != list.end(); i++) {

		bool found = false;

		for (RomDetails::XIPFileList::iterator j = details->iXIPFiles.begin(); j != details->iXIPFiles.end(); j++){

			fs::path e32filePath(j->iE32File);

			String e32FileName(e32filePath.leaf());

			if ((*i) == e32FileName){

				found = true;

				break;

			}

		}

		if (!found){

			cerr << "WARNING: " << (*i) << " not found in ROM\n";

		}

	}

}

static void CheckDebugXIPFiles(RomDetails * details){

	CheckXIPFiles(details, details->iTargetFiles);

}

static void CheckExcludeXIPFile(RomDetails * details){

	CheckXIPFiles(details, details->iExcludeFiles);

}

static void ProcessXIPFiles(string::const_iterator & start, string::const_iterator & end, 

		string::const_iterator & rest, RomDetails * details){

	while (ProcessXIPFile(start,end,rest,details)){

		start = rest;

	}

	CheckDebugXIPFiles(details);

	CheckExcludeXIPFile(details);

}

static void ProcessRomDetails(string::const_iterator & start, string::const_iterator & end, 

								string::const_iterator & rest, RomDetails * details){

	const char * align  = "Linear base address:\\s*([\\S]+)$";

	boost::regex e(align);

	boost::match_results<string::const_iterator> what;

	if (boost::regex_search(start, end, what, e)){ 

		string offender(what[0].first, what[0].second);

		string lbas(what[1].first, what[1].second);

		details->iRomBaseLinearAddr = ConvertToUnsignedLong(lbas, offender);

	} else {

        cerr << "Error: " << details->iLogFile << " not a valid ROM log file. Could not find Linear base address." << "\n";

        exit(EXIT_FAILURE) ;		

	}

}

static fs::path FindBuildPath(RomDetails * details){

	const string epoc32("epoc32");

	const string builddir("build");

	const string epocRoot(getenv("EPOCROOT"));

	if (details->iDrive.size() > 0) {

		string drive(details->iDrive);

		if (drive.size() == 1){

			drive += ":";

		} else if (((drive.size() == 2) && (drive[drive.size()-1] != ':')) || (drive.size() > 2)){

	        cerr << "Error: Invalid drive specification: " << drive << "\n";

	        exit(EXIT_FAILURE) ;			

		}

		fs::path buildpath(drive);

		buildpath /= epocRoot;

		buildpath /= epoc32;

		buildpath /= builddir;

		return buildpath;

	}

	fs::path primary_path(details->iPrimary.iE32File);

	fs::path buildpath;

	for (fs::path::iterator i = primary_path.begin(); i != primary_path.end(); i++){

		string item(*i);

		downcase(item);

		buildpath /= item;

		if (item == epoc32) {

			buildpath /= builddir;

			break;

		}

	}

	return buildpath;

}

class PathCache {

public:

	typedef std::map<string, string> PathMap;

	PathCache(fs::path & apath):

		iBuildPath(apath)

		{

			if (fs::exists(apath)){

				fs::recursive_directory_iterator i(apath);

				iCurrent = i;

			}

		}

	bool FindPath(string & pattern, string & result);

	fs::path & GetBuildPath() { return iBuildPath; }

private:

	bool GetNextPath(string & path);

	bool Filtered(fs::path & path);

private:

	fs::path iBuildPath;

	fs::recursive_directory_iterator iCurrent;

	fs::recursive_directory_iterator iEnd;

	PathMap iPathMap;

	static const std::string filters;

};

bool PathCache::Filtered(fs::path & apath){

	std::string ext(fs::extension(apath));

	downcase(ext);

	if (ext.size() > 0){

		if (filters.find(ext) != std::string::npos)

			return true;

	} 

	return false;

}

bool PathCache::GetNextPath(string & path){

	 for (; iCurrent != iEnd; ++iCurrent ){

		 if (fs::is_directory(iCurrent->status()))

			 continue;

		 fs::path candidate(iCurrent->path());

		 if (!Filtered(candidate)) {

			 path = candidate.string();

			 ++iCurrent;

			 return true;

		 }

	 }

	 return false;

}

static void GetTarget(string & source, string & target){

	fs::path t1(source);

	fs::path::iterator s = t1.begin();

	fs::path::iterator start = t1.end();

	int n = 0;

	for (; n < 3 && s != start; n++, start--){}

	if (n < 3) {

		warnx(0, "%s does not have 3 elements\n", source.c_str());

	}

	fs::path q;

	for (; start != t1.end(); start++){

		q /= fs::path(*start);

	}

	target = q.string();

	downcase(target);

}

bool PathCache::FindPath(string & source, string & result){

	string ss;

	if (source.size() == 0) return false;

	GetTarget(source, ss);

	// now check the cache

	PathMap::iterator res = iPathMap.find(ss);

	if (res != iPathMap.end()){

		result = res->second;

		return true;

	}

	// otherwise iterate until we find a match

	string candidate;

	while (GetNextPath(candidate)){

		downcase(candidate);

		size_t n = candidate.rfind(ss);

		if (n != string::npos){

			size_t csize = candidate.size();

			size_t sssize = ss.size();

			if ((csize - sssize) == n){

				// put it in cache anyway just in case its the primary

				iPathMap[ss] = candidate;

				result = candidate;

				return true;

			}

		}

		string x;

		GetTarget(candidate, x);

		iPathMap[x] = candidate;

	}

	return false;

}

const std::string PathCache::filters(

		".cpp"

		".h"

		".mk"

		".o"

		".in"

		".via"

		".mbg"

		".rsg"

		".bat"

		".make"

		".def"

		".armv5"

	);

static bool FindSymFile(XIPFileDetails & detail, string & rootname){

	fs::path buildpath(rootname);

	fs::path e32path(detail.iE32File);

	buildpath /= e32path;

	// check for pre-RAPTOR .sym file

	fs::path elfpath = fs::change_extension(buildpath, ".sym");

	if (fs::exists(elfpath)) {

		detail.iElfFile = elfpath.string();

		return true;

	}

	// check for RAPTOR .sym file

	fs::path symPath(buildpath.string() + ".sym");

	if (fs::exists(symPath)) {

		detail.iElfFile = symPath.string();

		return true;

	}	

	return false;

}