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 y = 0; y < max_y; y++) {
	    for (int x=0;x<max_x - (y % 2);x++) {
                final Position p = new Position(x, y);
                feld[x][y] = new Zelle(p, Zelle.TOT);
            }
        }
    }

    private boolean isValid(int x, int y)
    {
	return x >= 0 && x < max_x && y >= 0 && y < max_y;
    }

    /**
     * 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 (isValid(p.getX(), p.getY())) {
            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 (isValid(p.getX(), p.getY())) {
            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<>();
	if (zelle == null)
	    return result;
        Position pos = zelle.getPosition();
	Position[] offsets = { new Position(0, -1), new Position(1, -1)
			       , new Position(-1, 0), new Position(1, 0)
			       , new Position(0, 1), new Position (1, 1)
	};
        for (Position offset : offsets) {
	    Zelle nachbar = this.getZelle(pos.add(offset));
	    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;
    }
}