/*
 * Copyright (C) 2007 Steve Ratcliffe
 * 
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 * 
 *  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.
 * 
 * 
 * Author: Steve Ratcliffe
 * Create date: Nov 15, 2007
 */
package uk.me.parabola.mkgmap.combiners;

import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import uk.me.parabola.imgfmt.FileExistsException;
import uk.me.parabola.imgfmt.FileNotWritableException;
import uk.me.parabola.imgfmt.FileSystemParam;
import uk.me.parabola.imgfmt.MapFailedException;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.app.mdr.MdrConfig;
import uk.me.parabola.imgfmt.app.srt.SRTFile;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.fs.FileSystem;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.imgfmt.mps.MapBlock;
import uk.me.parabola.imgfmt.mps.MpsFile;
import uk.me.parabola.imgfmt.mps.MpsFileReader;
import uk.me.parabola.imgfmt.mps.ProductBlock;
import uk.me.parabola.imgfmt.sys.FileImgChannel;
import uk.me.parabola.imgfmt.sys.FileLink;
import uk.me.parabola.imgfmt.sys.ImgFS;
import uk.me.parabola.log.Logger;
import uk.me.parabola.mkgmap.CommandArgs;

/**
 * Create the gmapsupp file.  There is nothing much special about this file
 * (as far as I know - there's not a public official spec or anything) it is
 * just a regular .img file which is why it works to rename a single .img file
 * and send it to the device.
 * <p/>
 * Effectively we just 'unzip' the constituent .img files and then 'zip' them
 * back into the gmapsupp.img file.
 * <p/>
 * In addition we need to create and add the MPS file, if we don't already
 * have one.
 *
 * @author Steve Ratcliffe
 */
public class GmapsuppBuilder implements Combiner {
	private static final Logger log = Logger.getLogger(GmapsuppBuilder.class);

	private static final String GMAPSUPP = "gmapsupp.img";

	private final Map<String, FileInfo> files = new LinkedHashMap<>();

	// all these need to be set in the init routine from arguments.
	private String areaName;
	private String mapsetName;

	private String overallDescription = "Combined map";
	private String outputDir;
	private MpsFile mpsFile;

	private boolean createIndex;	// True if we should create and add an index file

	// There is a separate MDR and SRT file for each family id in the gmapsupp
	private final Map<Integer, MdrBuilder> mdrBuilderMap = new LinkedHashMap<>();
	private final Map<Integer, Sort> sortMap = new LinkedHashMap<>();
	private MdrConfig mdrConfig; // one base config for all 
	private boolean hideGmapsuppOnPC;
	private int productVersion;

	private FileSystem imgFs;

	public void init(CommandArgs args) {
		areaName = args.get("area-name", null);
		mapsetName = args.get("mapset-name", "OSM map set");
		overallDescription = args.getDescription();
		outputDir = args.getOutputDir();
		hideGmapsuppOnPC = args.get("hide-gmapsupp-on-pc", false);
		productVersion = args.get("product-version", 100);
		mdrConfig = new MdrConfig();
		mdrConfig.setIndexOptions(args);

		try {
			imgFs = createGmapsupp();
		} catch (FileNotWritableException e) {
			throw new MapFailedException("Could not create gmapsupp.img file");
		}
	}

	/**
	 * Add or retrieve the MDR file for the given familyId.
	 * @param familyId The family id to create the mdr file for.
	 * @param sort The sort for this family id.
	 * @return If there is already an mdr file for this family then it is returned, else the newly created
	 * one.
	 */
	private MdrBuilder addMdrFile(int familyId, Sort sort) {
		MdrBuilder mdrBuilder = mdrBuilderMap.get(familyId);
		if (mdrBuilder != null)
			return mdrBuilder;

		mdrBuilder = new MdrBuilder();

		try {
			String imgname = String.format("%08d.MDR", familyId);
			ImgChannel chan = imgFs.create(imgname);
			mdrBuilder.initForDevice(chan, sort, mdrConfig);
		} catch (FileExistsException e) {
			System.err.println("Could not create duplicate MDR file");
		}

		mdrBuilderMap.put(familyId, mdrBuilder);
		return mdrBuilder;
	}

	/**
	 * Add the sort file for the given family id.
	 */
	private void addSrtFile(int familyId, FileInfo info) {
		Sort prevSort = sortMap.get(familyId);
		Sort sort = info.getSort();
		if (prevSort == null) {
			if (info.getKind() == FileKind.IMG_KIND) {
				sortMap.put(familyId, sort);
			}
		} else {
			if (prevSort.getCodepage() != sort.getCodepage())
				System.err.printf("WARNING: input file '%s' has a different code page (%d rather than %d)\n",
						info.getFilename(), sort.getCodepage(), prevSort.getCodepage());
			if (info.hasSortOrder() && prevSort.getSortOrderId() != sort.getSortOrderId())
				System.err.printf("WARNING: input file '%s' has a different sort order (%x rather than %x\n",
						info.getFilename(), sort.getSortOrderId(), prevSort.getSortOrderId());
		}
	}

	/**
	 * This is called when the map is complete. We collect information about the map to be used in the TDB file and for
	 * preparing the gmapsupp file.
	 *
	 * @param info Information about the img file.
	 */
	public void onMapEnd(FileInfo info) {
		files.put(info.getFilename(), info);

		if (info.isImg()) {
			int familyId = info.getFamilyId();
			if (createIndex) {
				MdrBuilder mdrBuilder = addMdrFile(familyId, info.getSort());
				mdrBuilder.onMapEnd(info);
			}

			addSrtFile(familyId, info);
		}
	}

	/**
	 * The complete map set has been processed. Creates the gmapsupp file.  This is done by stepping through each img file,
	 * reading all the sub files and copying them into the gmapsupp file.
	 */
	public void onFinish() {

		for (MdrBuilder mdrBuilder : mdrBuilderMap.values()) {
			mdrBuilder.onFinishForDevice();
		}

		try {

			addAllFiles(imgFs);

			writeSrtFile(imgFs);
			writeMpsFile();

		} catch (FileNotWritableException e) {
			log.warn("Could not create gmapsupp file");
			System.err.println("Could not create gmapsupp file");
		} finally {
			Utils.closeFile(imgFs);
		}
	}

	/**
	 * Write the SRT file.
	 *
	 * @param imgFs The filesystem to create the SRT file in.
	 * @throws FileNotWritableException If it cannot be created.
	 */
	private void writeSrtFile(FileSystem imgFs) throws FileNotWritableException {
		for (Map.Entry<Integer, Sort> ent : sortMap.entrySet()) {
			Sort sort = ent.getValue();
			int familyId = ent.getKey();

			if (sort.getId1() == 0 && sort.getId2() == 0)
				return;

			try {
				ImgChannel channel = imgFs.create(String.format("%08d.SRT", familyId));
				SRTFile srtFile = new SRTFile(channel);
				srtFile.setSort(sort);
				srtFile.write();
				// Do not close srtFile here
			} catch (FileExistsException e) {
				// well it shouldn't exist!
				log.error("could not create SRT file as it exists already");
				throw new FileNotWritableException("already existed", e);
			}
		}
	}

	/**
	 * Write the MPS file.  The gmapsupp file will work without this, but it important if you want to include more than one
	 * map family and be able to turn them on and off separately.
	 */
	private void writeMpsFile() throws FileNotWritableException {
		try {
			mpsFile.sync();
		} catch (IOException e) {
			throw new FileNotWritableException("Could not finish write to MPS file", e);
		}
	}

	private MapBlock makeMapBlock(FileInfo info) {
		MapBlock mb = new MapBlock(info.getCodePage());
		mb.setMapNumber(info.getMapnameAsInt());
		mb.setHexNumber(info.getHexname());
		mb.setMapDescription(info.getDescription());
		mb.setAreaName(areaName != null ? areaName : "Area " + info.getMapname());

		mb.setSeriesName(info.getSeriesName());
		mb.setIds(info.getFamilyId(), info.getProductId());
		return mb;
	}

	private ProductBlock makeProductBlock(FileInfo info) {
		ProductBlock pb = new ProductBlock(info.getCodePage());
		pb.setFamilyId(info.getFamilyId());
		pb.setProductId(info.getProductId());
		pb.setDescription(info.getFamilyName());
		return pb;
	}

	private void addAllFiles(FileSystem outfs) {
		for (FileInfo info : files.values()) {

			switch (info.getKind()) {
			case IMG_KIND:
				addImg(outfs, info);
				addMpsEntry(info);
				break;
			case GMAPSUPP_KIND:
				addImg(outfs, info);
				addMpsFile(info);
				break;
			case APP_KIND:
			case TYP_KIND:
				addFile(outfs, info);
				break;
			default:
				break;
			}
		}
	}

	private void addImg(FileSystem outfs, FileInfo info) {
		FileCopier fc = new FileCopier(info.getFilename());
		List<SubFileInfo> subFiles = info.subFiles();

		for (SubFileInfo sf : subFiles) {
			try {
				ImgChannel chan = outfs.create(sf.getName());
				Closeable sync = fc.add(sf.getName(), chan);

				((FileLink)chan).link(sf, sync);
			} catch (FileExistsException e) {
				log.warn("Could not copy " + sf.getName(), e);
			}
		}
	}

	private void addFile(FileSystem outfs, FileInfo info) {
		String filename = info.getFilename();
		FileCopier fc = new FileCopier(filename);

		try {
			ImgChannel chan = outfs.create(createImgFilename(filename));
			((FileLink) chan).link(info.subFiles().get(0), fc.file(chan));
		} catch (FileExistsException e) {
			log.warn("Counld not copy " + filename, e);
		}
	}

	/**
	 * Add a complete pre-existing mps file to the mps file we are currently
	 * building for this gmapsupp.
	 * @param info The details of the gmapsupp file that we need to extract the
	 */
	private void addMpsFile(FileInfo info) {
		String name = info.getFilename();
		try (FileSystem fs = ImgFS.openFs(name)) {
			MpsFileReader mr = new MpsFileReader(fs.open(info.getMpsName(), "r"), info.getCodePage());
			for (MapBlock block : mr.getMaps())
				mpsFile.addMap(block);

			for (ProductBlock b : mr.getProducts())
				mpsFile.addProduct(b);
			mr.close();
		} catch (IOException e) {
			log.error("Could not read MPS file from gmapsupp", e);
		}
	}

	/**
	 * Add a single entry to the mps file.
	 * @param info The img file information.
	 */
	private void addMpsEntry(FileInfo info) {
		mpsFile.addMap(makeMapBlock(info));

		// Add a new product block if we have found a new product
		mpsFile.addProduct(makeProductBlock(info));
	}

	private MpsFile createMpsFile(FileSystem outfs) throws FileNotWritableException {
		try {
			ImgChannel channel = outfs.create("MAKEGMAP.MPS");
			return new MpsFile(channel);
		} catch (FileExistsException e) {
			// well it shouldn't exist!
			log.error("could not create MPS file as it already exists");
			throw new FileNotWritableException("already existed", e);
		}
	}


	/**
	 * Create a suitable filename for use in the .img file from the external
	 * file name.
	 *
	 * The external file name might look something like /home/steve/foo.typ
	 * or c:\maps\foo.typ and we need to take the filename part and make
	 * sure that it is no more than 8+3 characters.
	 *
	 * @param pathname The external filesystem path name.
	 * @return The filename part, will be restricted to 8+3 characters and all
	 * in upper case.
	 */
	private String createImgFilename(String pathname) {
		File f = new File(pathname);
		String name = f.getName().toUpperCase(Locale.ENGLISH);
		int dot = name.lastIndexOf('.');

		String base = name.substring(0, dot);
		if (base.length() > 8)
			base = base.substring(0, 8);

		String ext = name.substring(dot + 1);
		if (ext.length() > 3)
			ext = ext.substring(0, 3);

		return base + '.' + ext;
	}

	/**
	 * Create the output file.
	 *
	 * @return The gmapsupp file.
	 * @throws FileNotWritableException If it cannot be created for any reason.
	 */
	private FileSystem createGmapsupp() throws FileNotWritableException {

		// Create this file, containing all the sub files
		FileSystemParam params = new FileSystemParam();
		params.setMapDescription(overallDescription);
		params.setGmapsupp(true);
		params.setHideGmapsuppOnPC(hideGmapsuppOnPC);
		params.setProductVersion(productVersion);

		FileSystem outfs = ImgFS.createFs(Utils.joinPath(outputDir, GMAPSUPP), params);

		mpsFile = createMpsFile(outfs);
		mpsFile.setMapsetName(mapsetName);

		return outfs;
	}

	public void setCreateIndex(boolean create) {
		this.createIndex = create;
	}
}

/**
 * Copies files from the source img to the gmapsupp.
 *
 * Each sub file has to be copied separately to a different 'file'.  This class makes sure
 * that the source file is only opened once.
 */
class FileCopier {
	private final String filename;
	private FileSystem fs;
	private int refCount;

	public FileCopier(String filename) {
		this.filename = filename;
	}

	Closeable add(String name, ImgChannel fout) {
		refCount++;
		return () -> sync(name, fout);
	}

	Closeable file(ImgChannel fout) {
		return () -> sync(fout);
	}

	/**
	 * This version of sync() is used for single files.
	 */
	public void sync(ImgChannel fout) throws IOException {
		try (ImgChannel fin = new FileImgChannel(filename, "r")) {
			copyFile(fin, fout);
		}
	}

	/**
	 * This version of sync is used for subfiles within a .img file.
	 * @param name The sub file name.
	 * @param fout Where to copy the file
	 */
	void sync(String name, ImgChannel fout) throws IOException {
		if (fs == null)
			fs = ImgFS.openFs(filename);

		copyFile(name, fout);

		refCount--;
		if (refCount <= 0) {
			fs.close();
		}
	}

	private void copyFile(String name, ImgChannel fout) throws IOException {
		try (ImgChannel fin = fs.open(name, "r")) {
			copyFile(fin, fout);
		}
	}

	private void copyFile(ImgChannel fin, ImgChannel fout) throws IOException {
		ByteBuffer buf = ByteBuffer.allocate(1024);
		while (fin.read(buf) > 0) {
			buf.flip();
			fout.write(buf);
			buf.compact();
		}
	}
}
