package de.lmu.tcs;

import java.util.ArrayList;
import java.util.Collections;

/**
 * Model
 *
 * Created by jost on 24.11.15.
 */
public class Spielfeld {

    private final Zelle[][] feld;
    private final int max_x; //Breite
    private final int max_y; //Höhe

    public Spielfeld(int breite, int höhe) {
        this.max_x = breite;
        this.max_y = höhe;
        feld = new Zelle[this.max_x][this.max_y];
        for (int x=0;x<max_x;x++) {
            for (int y = 0; y < max_y; y++) {
                final Position p = new Position(x, y);
                feld[x][y] = new Zelle(p, Zelle.TOT);
            }
        }
    }

    /**
     * Liefert Zelle des Spielfelds an einer Position.
     * @param p Position, der Zelle ausgelesen werden soll
     * @return Zelle des Spielfelds an dieser Position, falls vorhanden; sonst null.
     */
    public Zelle getZelle(Position p) {
        if (p.getX() >= 0 && p.getX() < max_x && p.getY() >= 0 && p.getY() < max_y) {
            return feld[p.getX()][p.getY()];
        } else {
            return null;
        }
    }

    /**
     * Setzt eine gegebene Zelle ins Spielfeld ein.
     * Überschreibt vorherige Zelle.
     *
     * @param zelle Einzusetzende Zelle
     * @return Ob die Position der Zelle im Spielfeld enthalten ist (false bedeutuet ungültig).
     */
    public boolean setZelle(Zelle zelle) {
        final Position p = zelle.getPosition();
        if (p.getX() >= 0 && p.getX() < max_x && p.getY() >= 0 && p.getY() < max_y) {
            feld[p.getX()][p.getY()] = zelle;
            return true;
        } else {
            return false;
        }
    }

    /**
     * Liefert das gesamte Spielfeld direkt aus;
     * nicht so schöne, da interne Repräsentierung offenbart wird
     * und das Array von aussen verändert werden kann! Autsch!
     *
     * @return Alle Zellen des Felds im 2D array
     */
    public Zelle[][] getFeld() {
        return feld;
    }

    /**
     * BESSERE ALTERNATIVE zu getter-Methode getFeld():
     * Liefert alle Zellen des Spielfeldes aus. Vorteile:
     * 1) Interne Repräsentation bleibt versteckt.
     * 2) Da die Zellen immutable sind, kann hier das
     * Spielfeld auch nicht woanders manipuliert werden.
     *
     * @return Alle Zellen des Spielfeldes als ArrayList
     */
    public ArrayList<Zelle> getZellen() {
        ArrayList<Zelle> result = new ArrayList<>(max_x*max_y);
        for (int x=0;x<max_x;x++) {
            for (int y = 0; y < max_y; y++) {
                result.add(feld[x][y]);
            }
        }

        return result;
    }

    /**
     * Genau wie getZellen, nur mit echtem Array anstatt ArrayList.
     * Vorteile bleiben erhalten!
     *
     * @return Alle Zellen des Spielfeldes als Array
     */
    public Zelle[] getZellenAry() {
        Zelle[] result = new Zelle[max_x*max_y];
        int i = 0;
        for (int x=0;x<max_x;x++) {
            for (int y = 0; y < max_y; y++) {
                result[i] = feld[x][y];
                i++;
            }
        }
        return result;
    }

    /**
     * Berechnet alle Nachbarn einer Zelle.
     *
     * @param zelle deren Nachbarn berechnet werden sollen
     * @return alle Nachbarn von {@code zelle}, Anzahl Nachbarn variabel
     */
    public ArrayList<Zelle> getNachbarn(Zelle zelle) {
        ArrayList<Zelle> result = new ArrayList<>();
        Position pos = zelle.getPosition();
        for (int x=-1; x<=1; x++) {
            for (int y = -1; y <= 1; y++) {
                if (x!=0 || y!=0) {
                    Zelle nachbar = this.getZelle(new Position(pos.getX() + x, pos.getY() + y));
                    if (nachbar != null) {
                        result.add(nachbar);
                    }
                }
            }
        }
        return result;
    }

    /**
     * Berechnet alle Nachbarn einer Zelle.
     * Variante von getNachbar mit Array anstatt ArrayList
     *
     * @param zelle deren Nachbarn berechnet werden sollen
     * @return alle Nachbarn von {@code zelle}, Anzahl Nachbarn variabel
     */
   public Zelle[] getNachbarnAry(Zelle zelle) {
        Position pos = zelle.getPosition();
        int minx = Math.max(pos.getX() - 1, 0);
        int maxx = Math.min(pos.getX() + 1, this.max_x);
        int miny = Math.max(pos.getY() - 1, 0);
        int maxy = Math.min(pos.getY() + 1, this.max_y);
        Zelle[] result = new Zelle[maxx - minx * maxy - miny];
        int i = 0;
        for (int x = minx; x <= maxx; x++) {
            for (int y = miny; y <= maxy; y++) {
                if (x!=0 || y!=0) {
                    result[i] = feld[x][y];
                    i++;
                }
            }
        }
        return result;
    }

    /**
     * Berechnet alle Nachbarn einer Zelle auf Wrap-Around Spielfeld..
     *
     * @param zelle deren Nachbarn berechnet werden sollen
     * @return alle Nachbarn von {@code zelle}, Anzahl Nachbarn variabel
     */
    public ArrayList<Zelle> getNachbarnWrapped(Zelle zelle) {
        ArrayList<Zelle> result = new ArrayList<Zelle>(8);
        Position pos = zelle.getPosition();
        for (int x = -1; x <= 1; x++) {
            for (int y = -1; y <= 1; y++) {
                if (x!=0 || y!=0) {
                    Zelle z =  getZelle(new Position((pos.getX() + x + max_x )% max_x, (pos.getY() + y + max_y) % max_y));
                    result.add(z);
                }
            }
        }
        return result;
    }

    /**
     * Berechnet alle Nachbarn einer Zelle auf Warap-Around Spielfeld.
     * Variante von getNachbarWrapped mit Array anstatt ArrayList
     *
     * @param zelle deren Nachbarn berechnet werden sollen
     * @return alle Nachbarn von {@code zelle}, Anzahl Nachbarn variabel
     */
    public Zelle[] getNachbarnAryWrapped(Zelle zelle) {
        Zelle[] result = new Zelle[8];
        Position pos = zelle.getPosition();
        int i = 0;
        for (int x = -1; x <= 1; x++) {
            for (int y = -1; y <= 1; y++) {
                if (x!=0 || y!=0) {
                    Zelle z =  getZelle(new Position((pos.getX() + x + max_x )% max_x, (pos.getY() + y + max_y) % max_y));
                    result[i] = z;
                    i++;
                }
            }
        }
        return result;
    }
}