package rtr.font.localization;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.Properties;

import org.newdawn.slick.Image;
import org.newdawn.slick.SlickException;
import org.yaml.snakeyaml.Yaml;

import rtr.ImageLoader;
import rtr.font.FontModule.FontType;
import rtr.utilities.YAMLFlattener;
import rtr.utilities.Utilities;

public class LocalizationTemplate {

	private File languageFolderPath;
	private String languageFolderName;
	private String languageName, languageAuthor, fontNameBody, fontNameHeader, languageLink;
	private int[] glyphRangeStart = new int[10];
	private int[] glyphRangeStop = new int[10];

	private int fontHeaderSizeOffset, fontBodySizeOffset, fontHeaderXOffset, fontHeaderYOffset, fontBodyXOffset, fontBodyYOffset;

	private double percentCompleted;
	private String languageIconRef;
	private Image icon;

	public LocalizationTemplate(String absolutePath, boolean workshop) {
		//absolutePath = absolutePath.replace("\\","/");
		absolutePath = absolutePath.replace("\\", File.separator);
		languageFolderPath = new File(absolutePath);
		int lastIndexOf = absolutePath.lastIndexOf('\\');

		System.out.println(absolutePath);
		if (lastIndexOf != -1)
			languageFolderName = absolutePath.substring(lastIndexOf).replace("\\", "");
		else
			languageFolderName = absolutePath;
		System.out.println(absolutePath);

		Properties languageConfig = new Properties();

		FileInputStream in;
		try {
			in = new FileInputStream(languageFolderPath+"/configuration.properties");
			languageConfig.load(in);
			in.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

		languageName = languageConfig.getProperty("languageName");
		languageAuthor = languageConfig.getProperty("languageAuthor");

		fontNameHeader = languageConfig.getProperty("fontNameHeader");
		fontNameBody = languageConfig.getProperty("fontNameBody");

		for (int x = 0; x < glyphRangeStart.length; x++) {
			if (!languageConfig.getProperty("glyphRangeStart"+x, "0").equals("0")) {
				glyphRangeStart[x] = Integer.parseInt(languageConfig.getProperty("glyphRangeStart"+x), 16);
				glyphRangeStop[x] = Integer.parseInt(languageConfig.getProperty("glyphRangeStop"+x), 16);
			}
		}

		fontBodySizeOffset = Integer.parseInt(languageConfig.getProperty("fontBodySizeOffset", "0"));
		fontHeaderSizeOffset = Integer.parseInt(languageConfig.getProperty("fontHeaderSizeOffset", "0"));

		fontBodyXOffset = Integer.parseInt(languageConfig.getProperty("fontBodyXOffset", "0"));
		fontBodyYOffset = Integer.parseInt(languageConfig.getProperty("fontBodyYOffset", "0"));

		fontHeaderXOffset = Integer.parseInt(languageConfig.getProperty("fontHeaderXOffset", "0"));
		fontHeaderYOffset = Integer.parseInt(languageConfig.getProperty("fontHeaderYOffset", "0"));

		languageIconRef = languageConfig.getProperty("languageIcon", "noFlag");

		if (workshop) {
			languageLink = "https://steamcommunity.com/sharedfiles/filedetails/?id="+languageFolderName;
		}else {
			languageLink = languageConfig.getProperty("languageLink");
		}
		calculatePercentage();
	}

	private void calculatePercentage() {
		if (languageFolderPath.toString().contains("defaultEnglish")) {
			percentCompleted = 100.0;
		}else {

		    Charset UTF_8 = Charset.forName("UTF-8");
			Map<String, Object> defaultEnglishMap = null;
			try {
				File fileDir = new File("localization/defaultEnglish/text.yml");

				InputStreamReader in = new InputStreamReader(new FileInputStream(fileDir), UTF_8);
				defaultEnglishMap = new Yaml().loadAs(in, Map.class);
				defaultEnglishMap = YAMLFlattener.flattenYamlTree(defaultEnglishMap);
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}

			Map<String, Object> thisMap = null;
			try {
				File fileDir = new File(languageFolderPath+"/text.yml");

				InputStreamReader in = new InputStreamReader(new FileInputStream(fileDir), UTF_8);
				thisMap = new Yaml().loadAs(in, Map.class);
				thisMap = YAMLFlattener.flattenYamlTree(thisMap);
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}

			int totalDefaultEnglishKeys = 0;
			int totalNewKeys = 0;
			for (Object rawKey : defaultEnglishMap.keySet()) {
				if (rawKey.toString().contains(".text")) {
					totalDefaultEnglishKeys++;
				}
			}

			k:
			for (String thisKey : thisMap.keySet()) {
				if (thisKey.endsWith(".text")) {
					String forceCheck = thisKey.replace(".text", ".forceCount");
					if (thisMap.containsKey(forceCheck)) {
						totalNewKeys++;
						continue k;
					}

					for (String defaultKey : defaultEnglishMap.keySet()) {
						if (thisKey.equals(defaultKey)) {
								if (!thisMap.get(thisKey).equals("")
									&& !thisMap.get(thisKey).equals(" ")
									&& !thisMap.get(thisKey).toString().equals(defaultEnglishMap.get(defaultKey).toString())) {
								totalNewKeys++;
								continue k;
							}
						}
					}

					//System.out.println(thisKey+" "+thisMap.get(thisKey));
				}
			}

			if (totalNewKeys == totalDefaultEnglishKeys) {
				percentCompleted = 100.0;
			} else {
				percentCompleted = ((totalNewKeys*1.0)/(totalDefaultEnglishKeys*1.0)) * 100.0;
				percentCompleted = Double.parseDouble((Double.toString(percentCompleted)).substring(0, 4));
			}
		}
	}

	public File getLanguageFolderPath() {return languageFolderPath;}
	public String getLanguageName() {return languageName;}
	public String getLanguageAuthor() {return languageAuthor;}
	public String getFontName(FontType type) {
		if (type == FontType.BODY)
			return fontNameBody;
		else
			return fontNameHeader;
	}
	public int[] getGlyphRangeStart() {return glyphRangeStart;}
	public int[] getGlyphRangeStop() {return glyphRangeStop;}
	public int getFontSizeOffset(FontType type) {
		if (type == FontType.BODY)
			return fontBodySizeOffset;
		else
			return fontHeaderSizeOffset;
	}
	public int getFontXOffset(FontType type) {
		if (type == FontType.BODY)
			return fontBodyXOffset;
		else
			return fontHeaderXOffset;
	}
	public int getFontYOffset(FontType type) {
		if (type == FontType.BODY)
			return fontBodyYOffset;
		else
			return fontHeaderYOffset;
	}


	public double getPercentCompleted() {return percentCompleted;}

	public Image getIcon() {
		//This must be done here, because you need an OGL context available before you can load images, and these templates are loaded before the game is actually launched.
		if (icon == null) {
			try {
				File localFolderIcon = new File(languageFolderPath+"\\"+languageIconRef+".png");
				File flagFolderIcon = new File("localization/flags/"+languageIconRef+".png");
				if (localFolderIcon.exists())
					icon = ImageLoader.getImage(localFolderIcon.toString());
				else if (flagFolderIcon.exists())
					icon = ImageLoader.getImage(flagFolderIcon.toString());
				else
					icon = ImageLoader.getImage("localization/flags/noFlag.png");
			} catch (SlickException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return icon;
	}

	public File getTextFilePath() {return new File(languageFolderPath+"\\text.yml");}
	public String getLanguageFolderName() {return languageFolderName;}
	public String getLanguageLink() {return languageLink;}
}