/*

 * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game

 * Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.com>

 *

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

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

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

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 */

package org.hedgewars.hedgeroid.frontlib;

import java.io.UnsupportedEncodingException;

import java.util.ArrayList;

import java.util.Arrays;

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;

        }

    }

    public static class ByteArrayPtr extends PointerType {

        public byte[] deref(int size) {

            return getPointer().getByteArray(0, size);

        }

        public static byte[] deref(ByteArrayPtr ptr, int size) {

            if(ptr==null && size==0) {

                return null;

            } else {

                return ptr.deref(size);

            }

        }

        public static ByteArrayPtr createJavaOwned(byte[] buffer) {

            if(buffer == null || buffer.length == 0) {

                return null;

            }

            // no need for javaOwnedInstance here because PointerType

            // remembers the memory as its Pointer

            Pointer ptr = new Memory(buffer.length);

            ptr.write(0, buffer, 0, buffer.length);

            ByteArrayPtr result = new ByteArrayPtr();

            result.setPointer(ptr);

            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 {}

        public HogStruct() { super(); }

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

        @Override

        protected List<String> getFieldOrder() {

            return Arrays.asList("name", "hat", "rounds", "kills", "deaths", "suicides", "difficulty", "initialHealth", "weaponset");

        }

        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 {}

        public TeamStruct() { super(); }

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

        @Override

        protected List<String> getFieldOrder() {

            return Arrays.asList("hogs", "name", "grave", "fort", "voicepack", "flag", "bindings", "bindingCount", "rounds", "wins", "campaignProgress", "colorIndex", "hogsInGame", "remoteDriven", "ownerName");

        }

        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 {}

        public WeaponsetStruct() { super(); }

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

        @Override

        protected List<String> getFieldOrder() {

            return Arrays.asList("loadout", "crateprob", "crateammo", "delay", "name");

        }

        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));

        }