package org.hedgewars.hedgeroid.frontlib;

import java.io.UnsupportedEncodingException;

import java.nio.Buffer;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.hedgewars.hedgeroid.Datastructures.Hog;

import org.hedgewars.hedgeroid.Datastructures.MapRecipe;

import org.hedgewars.hedgeroid.Datastructures.MetaScheme;

import org.hedgewars.hedgeroid.Datastructures.MetaScheme.Mod;

import org.hedgewars.hedgeroid.Datastructures.MetaScheme.Setting;

import org.hedgewars.hedgeroid.Datastructures.GameConfig;

import org.hedgewars.hedgeroid.Datastructures.Room;

import org.hedgewars.hedgeroid.Datastructures.Scheme;

import org.hedgewars.hedgeroid.Datastructures.Team;

import org.hedgewars.hedgeroid.Datastructures.TeamInGame;

import org.hedgewars.hedgeroid.Datastructures.TeamIngameAttributes;

import org.hedgewars.hedgeroid.Datastructures.Weaponset;

import com.sun.jna.Callback;

import com.sun.jna.Library;

import com.sun.jna.Memory;

import com.sun.jna.Pointer;

import com.sun.jna.PointerType;

import com.sun.jna.Structure;

/**

 * Here is an introduction to the most important aspects of the JNA code.

 * 

 * This interface permits access to the Hedgewars frontend library (frontlib)

 * from Java. Each function directly contained in the Frontlib interface

 * represents a mapped C function. The Structure classes (ending in -Struct) are

 * mappings of C structs, and the PointerType classes (ending in -Ptr) represent

 * pointers to structs.

 * 

 * Quick notes for USING these classes from outside this package:

 * 

 * Usage should be fairly straightforward, but there are a few surprising

 * gotchas. First, when you implement callbacks, YOU are responsible for

 * ensuring that the callback objects are not garbage-collected while they might

 * still be called! So make sure you keep them in member variables or similar,

 * because Java will not know if there are still native references to them.

 * 

 * When using Frontlib from outside its package, you only interact with structs

 * via the PointerType classes. They allow you to get at the data of the struct

 * with a function called deref(), which creates a plain normal Java object

 * representing the data (e.g. SchemePtr.deref() will give you a Scheme object).

 * 

 * Remember that you usually have to destroy structs that you receive from the

 * library, because they are owned by the native code, not Java. The recommended

 * pattern for most cases is to call deref() on the pointer to get a Java object

 * (that you can keep as long as you like), and then immediately destroy the

 * struct if it needs destroying. To find out whether and how the struct needs

 * to be destroyed, see the library's documentation of the function that you got

 * the struct from.

 * 

 * To pass new structs to the library, you can use the static createJavaOwned()

 * function in each PointerType, which creates a new struct from the Java object

 * you provide, and returns a pointer to that struct that you can pass to

 * library functions. This new structure's memory is owned and managed by Java

 * code, so do not destroy it with frontlib functions!

 * 

 * There is a slight mismatch between the data model for the game setup. The

 * frontlib supports setting initial health and weaponset per-hog, because the

 * engine allows for that, but currently neither the networking protocol nor the

 * PC frontend support this feature, so the Android version does not take

 * advantage of it either and treats both as per-game settings. The initial

 * health is contained in the game scheme, the weaponset is explicitly part of

 * the GameConfig. When converting GameConfig to a native flib_gamesetup, both

 * are automatically copied to all hogs in the game, and for the reverse

 * conversion the weaponset of the first hog of the first team is used as the

 * GameConfig weaponset. This means that GameConfig.weaponset will be null if

 * there are no teams in the game.

 * 

 * When starting a network game, you only need to query the GameSetupPtr from

 * the netconn and use it to create the gameconn - this is preferable to using

 * your own recreation of the game setup, because that way the same piece of

 * code is used to determine the game setup on all platforms.

 * 

 * The "context" parameter of the callbacks is never needed here because JNA

 * generates function code for each callback object. Don't worry about it, just

 * pass null for context and ignore the context parameter in the callbacks.

 * 

 * Finally, the library functions are documented in the actual library, not

 * here, so check the docs there to find out what exactly each function does!

 * 

 * Notes about the structure of this class (for the next one who has to touch

 * this...):

 * 

 * Java/C interop is quite fiddly and error-prone, so as long as things work,

 * try to stick to the established patterns.

 * 

 * Structure types should always be hidden from the outside world, because they

 * can be misused too easily. For example, if you get a Structure from the

 * library, change a String value in there and pass it back, JNA will re-write

 * that string using Java-owned memory without freeing the old native-owned

 * string, which causes a memory leak and possibly a double-free or other Bad

 * Things (tm). To avoid problems like this, Structure types are only used

 * internally, to map existing structures to Java types (without modifying them)

 * or to create brand-new, Java-owned structures. Both operations are exposed to

 * the outside through the PointerType classes corresponding to the structures

 * in question.

 * 

 * Since all of the struct mapping happens in Java, it is never checked against

 * the actual struct declarations in the library. That means strange things can

 * start happening at runtime if the frontlib structs are modified without

 * changing the mappings here to match. This also applies to the function

 * signatures: JNA checks whether the functions actually exist when loading the

 * library, but it has no way of knowing whether the signatures are correct. If

 * the signatures here deviate from those in the frontlib, you might get stack

 * corruption.

 * 

 * In order to check at least the function signatures, take a look at the file

 * extra/jnacontrol.c in the frontlib sources. You can validate whether the

 * function signatures are still correct by copy-pasting them into jnaControl.c

 * and compiling it against the frontlib headers. The typedefs and #defines in

 * that file will make the compiler see the Java method signatures as C function

 * declarations. Since the same functions are already declared in the frontlib

 * headers, the compiler will give you errors if the signatures don't match.

 */

public interface Frontlib extends Library {

	public static class NetconnPtr extends PointerType { }

	public static class MapconnPtr extends PointerType { }

	public static class GameconnPtr extends PointerType { }

	public static class MetaschemePtr extends PointerType {

		public MetaScheme deref() {

			return deref(getPointer());

		}

		public static MetaScheme deref(Pointer p) {

			MetaschemeStruct struct = new MetaschemeStruct(p);

			struct.read();

			return struct.toMetaScheme();

		}

	}

	public static class RoomArrayPtr extends PointerType { 

		public Room[] getRooms(int count) {

			Pointer ptr = getPointer();

			if(ptr == null) {

				return new Room[0];

			}

			Pointer[] untypedPtrs = ptr.getPointerArray(0, count);

			Room[] result = new Room[count];

			for(int i=0; i<count; i++) {

				result[i] = RoomPtr.deref(untypedPtrs[i]);

			}

			return result;

		}

	}

	public static class RoomPtr extends PointerType {

		public Room deref() {

			return deref(getPointer());

		}

		public static Room deref(Pointer p) {

			RoomStruct struct = new RoomStruct(p);

			struct.read();

			return struct.toRoomlistRoom();

		}

	}

	public static class TeamPtr extends PointerType {

		private TeamStruct javaOwnedInstance; 

		public TeamInGame deref() {

			TeamStruct struct = new TeamStruct(getPointer());

			struct.read();

			return struct.toTeamInGame();

		}

		public static TeamPtr createJavaOwned(Team t) {

			return createJavaOwned(new TeamInGame(t, null));

		}

		public static TeamPtr createJavaOwned(TeamInGame ingameTeam) {

			TeamPtr result = new TeamPtr();

			result.javaOwnedInstance = new TeamStruct();

			result.javaOwnedInstance.fillFrom(ingameTeam.team, ingameTeam.ingameAttribs);

			result.javaOwnedInstance.autoWrite();

			result.setPointer(result.javaOwnedInstance.getPointer());

			return result;

		}

	}

	public static class WeaponsetPtr extends PointerType {

		private WeaponsetStruct javaOwnedInstance; 

		public Weaponset deref() {

			WeaponsetStruct struct = new WeaponsetStruct(getPointer());

			struct.read();

			return struct.toWeaponset();

		}

		public static WeaponsetPtr createJavaOwned(Weaponset weaponset) {

			WeaponsetPtr result = new WeaponsetPtr();

			result.javaOwnedInstance = new WeaponsetStruct();

			result.javaOwnedInstance.fillFrom(weaponset);

			result.javaOwnedInstance.autoWrite();

			result.setPointer(result.javaOwnedInstance.getPointer());

			return result;

		}

	}

	public static class WeaponsetListPtr extends PointerType {

		private WeaponsetListStruct javaOwnedInstance;

		public List<Weaponset> deref() {

			WeaponsetListStruct struct = new WeaponsetListStruct(getPointer());

			struct.read();

			return struct.toWeaponsetList();

		}

		public static WeaponsetListPtr createJavaOwned(List<Weaponset> list) {

			WeaponsetListPtr result = new WeaponsetListPtr();

			result.javaOwnedInstance = new WeaponsetListStruct();

			result.javaOwnedInstance.fillFrom(list);

			result.javaOwnedInstance.autoWrite();

			result.setPointer(result.javaOwnedInstance.getPointer());

			return result;

		}

	}

	public static class MapRecipePtr extends PointerType {

		private MapRecipeStruct javaOwnedInstance;

		public MapRecipe deref() {

			MapRecipeStruct struct = new MapRecipeStruct(getPointer());

			struct.read();

			return struct.toMapRecipe();

		}

		public static MapRecipePtr createJavaOwned(MapRecipe recipe) {

			MapRecipePtr result = new MapRecipePtr();

			result.javaOwnedInstance = new MapRecipeStruct();

			result.javaOwnedInstance.fillFrom(recipe);

			result.javaOwnedInstance.autoWrite();

			result.setPointer(result.javaOwnedInstance.getPointer());

			return result;

		}

	}

	public static class SchemePtr extends PointerType {

		private SchemeStruct javaOwnedInstance;

		public Scheme deref() {

			SchemeStruct struct = new SchemeStruct(getPointer());

			struct.read();

			return struct.toScheme();

		}

		public static SchemePtr createJavaOwned(Scheme scheme) {

			SchemePtr result = new SchemePtr();

			result.javaOwnedInstance = new SchemeStruct();

			result.javaOwnedInstance.fillFrom(scheme);

			result.javaOwnedInstance.autoWrite();

			result.setPointer(result.javaOwnedInstance.getPointer());

			return result;

		}

	}

	public static class SchemelistPtr extends PointerType {

		private SchemelistStruct javaOwnedInstance;

		public List<Scheme> deref() {

			SchemelistStruct struct = new SchemelistStruct(getPointer());

			struct.read();

			return struct.toSchemeList();

		}

		public static SchemelistPtr createJavaOwned(List<Scheme> schemes) {

			SchemelistPtr result = new SchemelistPtr();

			result.javaOwnedInstance = new SchemelistStruct();

			result.javaOwnedInstance.fillFrom(schemes);

			result.javaOwnedInstance.autoWrite();

			result.setPointer(result.javaOwnedInstance.getPointer());

			return result;

		}

	}

	public static class GameSetupPtr extends PointerType {

		private GameSetupStruct javaOwnedInstance;

		public GameConfig deref() {

			GameSetupStruct struct = new GameSetupStruct(getPointer());

			struct.read();

			return struct.toGameConfig();

		}

		public static GameSetupPtr createJavaOwned(GameConfig conf) {

			GameSetupPtr result = new GameSetupPtr();

			result.javaOwnedInstance = new GameSetupStruct();

			result.javaOwnedInstance.fillFrom(conf);

			result.javaOwnedInstance.autoWrite();

			result.setPointer(result.javaOwnedInstance.getPointer());

			return result;

		}

	}

	static class HogStruct extends Structure {

		public static class ByVal extends HogStruct implements Structure.ByValue {}

		public static class ByRef extends HogStruct implements Structure.ByReference {}

		private static String[] FIELD_ORDER = new String[] {"name", "hat", "rounds", "kills", "deaths", "suicides", "difficulty", "initialHealth", "weaponset"};

		public HogStruct() { super(); setFieldOrder(FIELD_ORDER); }

		public HogStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }

		public void fillFrom(Hog hog) {

			difficulty = hog.level;

			hat = hog.hat;

			name = hog.name;

		}

		public Hog toHog() {

			return new Hog(name, hat, difficulty);

		}

		public String name;

		public String hat;

		public int rounds;

		public int kills;

		public int deaths;

		public int suicides;

		public int difficulty;

		public int initialHealth;

		public WeaponsetStruct.ByRef weaponset;

	}

	static class TeamStruct extends Structure {

		public static class ByVal extends TeamStruct implements Structure.ByValue {}

		public static class ByRef extends TeamStruct implements Structure.ByReference {}

		private static String[] FIELD_ORDER = new String[] {"hogs", "name", "grave", "fort", "voicepack", "flag", "bindings", "bindingCount", "rounds", "wins", "campaignProgress", "colorIndex", "hogsInGame", "remoteDriven", "ownerName"};

		public TeamStruct() { super(); setFieldOrder(FIELD_ORDER); }

		public TeamStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }

		public void fillFrom(Team team, TeamIngameAttributes attrs) {

			if(team != null) {

				name = team.name;

				grave = team.grave;

				flag = team.flag;

				voicepack = team.voice;

				fort = team.fort;

				if(team.hogs.size() != Team.HEDGEHOGS_PER_TEAM) {

					throw new IllegalArgumentException();

				}

				for(int i=0; i<hogs.length; i++) {

					hogs[i] = new HogStruct();

					hogs[i].fillFrom(team.hogs.get(i));

				}

			}

			if(attrs != null) {

				hogsInGame = attrs.hogCount;

				ownerName = attrs.ownerName;

				colorIndex = attrs.colorIndex;

				remoteDriven = attrs.remoteDriven;

			}

		}

		public void fillFrom(TeamInGame team, WeaponsetStruct.ByRef weaponset, int initialHealth) {

			fillFrom(team.team, team.ingameAttribs);

			for(int i=0; i<hogs.length; i++) {

				hogs[i].initialHealth = initialHealth;

				hogs[i].weaponset = weaponset;

			}

		}

		public Team toTeam() {

			List<Hog> hogList = new ArrayList<Hog>();

			for(int i=0; i<hogs.length; i++) {

				hogList.add(hogs[i].toHog());

			}

			return new Team(name, grave, flag, voicepack, fort, hogList);

		}

		public TeamIngameAttributes toTeamIngameAttributes() {

			return new TeamIngameAttributes(ownerName, colorIndex, hogsInGame, remoteDriven);

		}

		public TeamInGame toTeamInGame() {

			return new TeamInGame(toTeam(), toTeamIngameAttributes());

		}

		public HogStruct[] hogs = new HogStruct[Team.HEDGEHOGS_PER_TEAM];

		public String name;

		public String grave;

		public String fort;

		public String voicepack;

		public String flag;

		public Pointer bindings;

		public int bindingCount;

		public int rounds;

		public int wins;

		public int campaignProgress;

		public int colorIndex;

		public int hogsInGame;

		public boolean remoteDriven;

		public String ownerName;

	}

	static class WeaponsetStruct extends Structure {

		public static class ByVal extends WeaponsetStruct implements Structure.ByValue {}

		public static class ByRef extends WeaponsetStruct implements Structure.ByReference {}

		private static String[] FIELD_ORDER = new String[] {"loadout", "crateprob", "crateammo", "delay", "name"};

		public WeaponsetStruct() { super(); setFieldOrder(FIELD_ORDER); }

		public WeaponsetStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }

		public void fillFrom(Weaponset weaponset) {

			fillWeaponInfo(loadout, weaponset.loadout);

			fillWeaponInfo(crateprob, weaponset.crateProb);

			fillWeaponInfo(crateammo, weaponset.crateAmmo);

			fillWeaponInfo(delay, weaponset.delay);

			name = weaponset.name;

		}

		private static void fillWeaponInfo(byte[] array, String str) {

			for(int i=0; i<array.length-1; i++) {

				array[i] = (byte) (i<str.length() ? str.charAt(i) : '0');

			}

			array[array.length-1] = (byte)0;

		}

		public Weaponset toWeaponset() {

			return new Weaponset(name, weaponInfoToString(loadout), weaponInfoToString(crateprob), weaponInfoToString(crateammo), weaponInfoToString(delay));

		}

		private static String weaponInfoToString(byte[] array) {

			try {

				return new String(array, 0, array.length-1, "ASCII");

			} catch (UnsupportedEncodingException e) {

				throw new AssertionError();

			}

		}

		public byte[] loadout = new byte[Weaponset.WEAPONS_COUNT+1];

		public byte[] crateprob = new byte[Weaponset.WEAPONS_COUNT+1];

		public byte[] crateammo = new byte[Weaponset.WEAPONS_COUNT+1];

		public byte[] delay = new byte[Weaponset.WEAPONS_COUNT+1];

		public String name;

	}

	/**

	 * Represents a flib_weaponset*, for use as part of a flib_weaponset**

	 */

	static class WeaponsetPointerByReference extends Structure implements Structure.ByReference {

		private static String[] FIELD_ORDER = new String[] {"weaponset"};

		public WeaponsetPointerByReference() { super(); setFieldOrder(FIELD_ORDER); }

		public WeaponsetPointerByReference(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }

		public WeaponsetStruct.ByRef weaponset;

	}

	static class WeaponsetListStruct extends Structure {

		public static class ByVal extends WeaponsetListStruct implements Structure.ByValue {}

		public static class ByRef extends WeaponsetListStruct implements Structure.ByReference {}

		private static String[] FIELD_ORDER = new String[] {"weaponsetCount", "weaponsets"};

		public WeaponsetListStruct() { super(); setFieldOrder(FIELD_ORDER); }

		public WeaponsetListStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }

		public void fillFrom(List<Weaponset> list) {

			weaponsetCount = list.size();

			if(weaponsetCount<=0) {

				weaponsets = null;

			} else {

				weaponsets = new WeaponsetPointerByReference();

				Structure[] structs = weaponsets.toArray(weaponsetCount);

				for(int i=0; i<weaponsetCount; i++) {

					WeaponsetPointerByReference pstruct = (WeaponsetPointerByReference)structs[i];

					pstruct.weaponset = new WeaponsetStruct.ByRef();

					pstruct.weaponset.fillFrom(list.get(i));

				}

			}

		}

		/**

		 * Only use on native-owned structs!

		 * Calling this method on a Java-owned struct could cause garbage collection of referenced

		 * structures.

		 */

		public List<Weaponset> toWeaponsetList() {

			if(weaponsetCount<=0) {

				return new ArrayList<Weaponset>();

			} else {

				List<Weaponset> list = new ArrayList<Weaponset>(weaponsetCount);

				Structure[] structs = weaponsets.toArray(weaponsetCount);