import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

class OthelloBoardTest {
	public static void main(String args[]) {
		OthelloBoard ob = new OthelloBoard();
		ob.start();
	}
}

class OthelloBoard {
	private int size;				//Eine Seite des Othello-Boards(8, 10, 12, 14, 16)
	private char[][] squares;		//Zustand jeder Masse(B:schwarz, W:Weiß, N:Kein Stein)
	private int turnCount;			//Zählen Sie die Anzahl der Umdrehungen
	private int turnCountMax;		//Maximale Anzahl von Windungen(1 Seite*1 Seite-4)
	private char playerColor;		//Spieler Steinfarbe
	private char otherColor;		//Die Farbe des Steins des Gegners
	private int playerDiscNum;		//Anzahl der Spielersteine
	private int otherDiscNum;		//Anzahl der Steine des Gegners
	private final String alphabets = "abcdefghijklmnop";
									//Alphabet mit horizontalen Koordinaten

	//Konstrukteur
	public OthelloBoard() {
		this.size = 8;
//		this.size = askBoardSize();
		this.squares = new char[this.size][this.size];
		this.turnCount = 1;
		this.turnCountMax = this.size*this.size - 4;

		//Bringen Sie das Othello-Board sofort nach dem Start in den Zustand
		this.initializeBoard();
	}

	//Starten Sie Othello
	public void start() {
		//Verarbeitung vor dem Start
		this.askPlayerColor();
		boolean isPlayerTurn = this.getFirstMove();
		int skipCount = 0;
		//Verarbeitung jeder Runde
		System.out.println("Starten Sie Othello.");
		this.printBoard();
		while (this.turnCount <= turnCountMax) {
			//Bestimmen Sie, ob Sie die Runde überspringen möchten
			int skipFlag = this.checkSkipCount(isPlayerTurn, skipCount);
			if (skipFlag == 2) {
				break;
			} else if (skipFlag == 1) {
				isPlayerTurn = !isPlayerTurn;
				skipCount ++;
				continue;
			}
			//Wenn Sie nicht überspringen
			skipCount = 0;
			if (isPlayerTurn) {
				//Spieler an der Reihe
				System.out.println("\nTurn " + turnCount + ":Du bist dran.");
				this.askNewCoordinates(this.playerColor, this.otherColor);
			} else {
				//Der Gegner ist an der Reihe
				System.out.println("\nTurn " + turnCount + ":Ihr Gegner ist an der Reihe.");
				this.thinkNewCoordinates(this.otherColor, this.playerColor);
			}
			this.printBoard();
			//Verarbeitung für die nächste Runde
			this.turnCount ++;
			isPlayerTurn = !isPlayerTurn;
		}
		//Urteil über Sieg oder Niederlage
		this.printDiscNumber();
		this.printResult();
	}

	//Grenzen Sie automatisch ein, wo der nächste Stein platziert werden soll
	private void thinkNewCoordinates(char myColor, char enemyColor) {
		ArrayList<Candidate> candidates = new ArrayList<Candidate>();
	
		//Speichern Sie eine Liste der Orte, an denen Sie zuerst Steine legen können
		for (int y = 0; y < this.size; y ++) {
			for (int x = 0; x < this.size; x ++) {
				//Ignorieren Sie die nachfolgende Verarbeitung, wenn andere Steine platziert werden
				if (this.squares[y][x] != 'N') {
					continue;
				}
				//Wenn Sie den Stein des Gegners nicht umdrehen können, ignorieren Sie die nachfolgende Verarbeitung
				Coordinates newDisc = new Coordinates(x, y);
				ArrayList<Coordinates> discs = this.checkDiscsTurnedOverAllLine(
					myColor, enemyColor, newDisc, this.size*this.size);
				if (discs.isEmpty()) {
					continue;
				}
				//Registrieren Sie sich in der Kandidatenliste
				candidates.add(new Candidate(newDisc));
			}
		}
	
		//Wählen Sie zufällig einen aus jedem Kandidaten aus
		Coordinates newDisc = candidates.get(new Random().nextInt(candidates.size()));
		ArrayList<Coordinates> discs = this.checkDiscsTurnedOverAllLine(
			myColor, enemyColor, newDisc, this.size*this.size);
		this.putDisc(myColor, newDisc);
		this.turnOverDiscs(discs);
		this.printDiscsTurnedOver(discs);
	}

	//Bestimmen Sie, ob Sie die Runde überspringen möchten
	//0, wenn kein Überspringen erforderlich ist, 1, wenn ein Überspringen erforderlich ist und die vorherige Runde nicht übersprungen wurde
	//Gibt 2 zurück, wenn das Überspringen erforderlich ist und die vorherige Runde ebenfalls übersprungen wurde
	private int checkSkipCount(boolean isPlayerTurn, int skipCount) {
		char myColor;
		char enemyColor;
		int result = 0;

		if (isPlayerTurn) {
			myColor = this.playerColor;
			enemyColor = this.otherColor;
		} else {
			myColor = this.otherColor;
			enemyColor = this.playerColor;
		}
		if (! this.checkSquaresForNewDisc(myColor, enemyColor)) {
			//Spieler an der Reihe überspringen
			System.out.println("Die Wende wurde übersprungen.");
			result = 1;
			if (skipCount == 1) {
				//Wenn der Zug des Gegners bereits übersprungen wurde, endet das Spiel
				result = 2;
			}
		}
		return result;
	}

	//Der erste Zug entscheidet, welcher
	//Wenn der Spieler Kuroishi ist, ist der Spieler der Erste und wenn Shiraishi der Gegner der Erste ist.
	private boolean getFirstMove() {
		if (this.playerColor == 'B') {
			return true;
		} else {
			return false;
		}

	}

	//Drehen Sie den Stein um
	private void turnOverDiscs(ArrayList<Coordinates> discs) {
		for (int i = 0; i < discs.size(); i ++) {
			int x = discs.get(i).x;
			int y = discs.get(i).y;
			if (this.squares[y][x] == 'B') {
				this.squares[y][x] = 'W';
			} else if (this.squares[y][x] == 'W') {
				this.squares[y][x] = 'B';
			}
		}
	}

	//Platz zum Ablegen von Steinen(Ein Ort, an dem Sie andere Steine umdrehen können)Bestimmen Sie, ob es gibt
	private boolean checkSquaresForNewDisc(char myColor, char enemyColor) {
		for (int y = 0; y < this.size; y ++) {
			for (int x = 0; x < this.size; x ++) {
				if (this.squares[y][x] != 'N') {
					continue;
				}
				ArrayList<Coordinates> discs = this.checkDiscsTurnedOverAllLine(
						myColor, enemyColor, new Coordinates(x, y), 1);
				if (discs.size() >= 1) {
					return true;
				}
			}
		}
		return false;
	}

	//Akzeptieren Sie die Eingabe, bis der Ort für das Ablegen des Steins festgelegt ist
	private void askNewCoordinates(char myColor, char enemyColor) {
		while (true) {
			//Eingang
			System.out.println("\n Entscheiden Sie, wo der Stein abgelegt werden soll.");
			System.out.println("[x-Koordinate y-Koordinate](Beispiela1)：");
			Scanner sc = new Scanner(System.in);
			//Stellen Sie fest, ob es sich im Bereich des Othello-Boards befindet
			Coordinates newDisc = this.checkCoordinatesRange(sc.nextLine());
			if (newDisc.equals(-1, -1)) {
				//Wenn die Koordinaten falsch sind, geben Sie sie erneut ein
				System.out.println("Die Eingabe ist falsch.");
				continue;
			}
			if (this.squares[newDisc.y][newDisc.x] != 'N') {
				//Wenn ein Stein bereits platziert wurde, lassen Sie ihn erneut eingeben
				System.out.println("Ich habe schon einen Stein.");
				continue;
			}
			//Bestimmen Sie, ob der Stein des Gegners umgedreht werden kann
			ArrayList<Coordinates> discs = this.checkDiscsTurnedOverAllLine(
				myColor, enemyColor, newDisc, this.size*this.size);
			if (! discs.isEmpty()) {
				//Wenn es einen Stein gibt, der umgedreht werden kann, drehen Sie den Stein tatsächlich um
				this.putDisc(myColor, newDisc);
				this.turnOverDiscs(discs);
				this.printDiscsTurnedOver(discs);
				return;
			}
			System.out.println("Ich kann den Stein des Gegners nicht umdrehen.");
		}
	}

	//Stellen Sie fest, ob die vom Spieler eingegebenen Koordinaten im Bereich des Othello-Bretts liegen
	//Wenn das Urteil erfolgreich ist, werden die Koordinaten verwendet, und wenn das Urteil fehlschlägt, werden die Koordinaten verwendet.(-1, -1)Gib es zurück
	private Coordinates checkCoordinatesRange(String line) {
		String[] tokens = line.split(" ");
		//Lesen Sie die horizontalen Koordinaten aus dem ersten Buchstaben des Alphabets
		int x = this.alphabets.indexOf(tokens[0]);
		if (tokens[0].length() != 1 || x < 0 || this.size <= x) {
			return new Coordinates(-1, -1);
		}
		//Lesen Sie die vertikalen Koordinaten der verbleibenden Zeichen
		int y;
		try {
			y = Integer.parseInt(tokens[1]);
			if (y <= 0 || this.size < y) {
				return new Coordinates(-1, -1);
			}
		} catch (NumberFormatException e) {
			return new Coordinates(-1, -1);
		}
		return new Coordinates(x, y - 1);
	}

	//Bestimmen Sie, ob der Stein an den eingegebenen Koordinaten den Stein des Gegners umdrehen kann
	//Gibt die Koordinaten des Steins zurück, der als Arraylist umgedreht werden kann
	//Da der Maximalwert der Zahl, die umgedreht werden kann, durch das Argument countMax bestimmt werden kann,
	//1 reicht aus, um zu beurteilen, ob ein Stein an dieser Koordinate platziert werden kann
	//Größe, um alle Koordinaten eines Steins zurückzugeben, die umgedreht werden können*messen
	private ArrayList<Coordinates> checkDiscsTurnedOverAllLine(
		char myColor, char enemyColor, Coordinates myCoordinates, int countMax)
	{
		ArrayList<Coordinates> discs = new ArrayList<Coordinates>();
		//In jede Richtung scannen
		for (int d = 0; d < 8; d ++) {
			discs.addAll(this.checkDiscsTurnedOverOneLine(myColor, enemyColor, myCoordinates, d));
			//Wenn der Maximalwert des Steins, der umgedreht werden kann, überschritten wird, wird die Verarbeitung gestoppt.
			if (discs.size() > countMax) {
				break;
			}
		}
		return discs;
	}

	//Bestimmen Sie, ob der Stein an den eingegebenen Koordinaten den Stein des Gegners umdrehen kann
	//Die Scanrichtung ändert sich abhängig von der Argumentrichtung
	// 0:0 Grad, 1:45 Grad, 2:90 Grad, 3:135 Grad, 4:180 Grad, 5:225 Grad, 6:270 Grad, 7:315 Grad
	private ArrayList<Coordinates> checkDiscsTurnedOverOneLine(
		char myColor, char enemyColor, Coordinates myCoordinates, int direction)
	{
		//Scannen Sie einen Stein, der umgedreht werden kann
		Coordinates currentCoordinates = new Coordinates(myCoordinates);
		ArrayList<Coordinates> discs = new ArrayList<Coordinates>();
		//Scannen Sie weiter neben Ihnen, während die Steine Ihres Gegners weiterlaufen
		while (true) {
			//Finde die Koordinaten des nächsten Steins
			Coordinates nextDisc = this.getNextDiscCoordinates(currentCoordinates, direction);
			if (nextDisc.equals(-1, -1)) {
				//Gibt eine leere Liste zurück, wenn keine Steine zum Umdrehen vorhanden sind
				discs.clear();
				break;
			}
			if (this.squares[nextDisc.y][nextDisc.x] == enemyColor) {
				//Wenn sich neben Ihnen ein Stein eines Gegners befindet, registrieren Sie ihn vorübergehend in der Flip-Liste
				discs.add(nextDisc);
			} else if (this.squares[nextDisc.y][nextDisc.x] == myColor) {
				//Wenn Sie einen eigenen Stein daneben haben, geben Sie die Liste zurück
				break;
			} else {
				//Wenn sich kein Stein daneben befindet, geben Sie eine leere Liste zurück
				discs.clear();
				break;
			}
			//Fahren Sie mit dem nächsten Stein fort
			currentCoordinates.copy(nextDisc);
		}
		return discs;
	}

	//neben an(Kommt auf die Richtung an)Gibt die Koordinaten des Steins in zurück
	//Wenn die Koordinaten außerhalb des Bereichs liegen(-1, -1)Gib es zurück
	private Coordinates getNextDiscCoordinates(Coordinates myDisc, int direction) {
		//x-Koordinate
		int x = myDisc.x;
		if (direction == 0 || direction == 1 || direction == 7) {
			x ++; //0 Grad,45 Grad,315 Grad
		} else if (direction == 3 || direction == 4 || direction == 5) {
			x --;  //135 Grad,180 Grad,225 Grad
		}
		//y-Koordinate
		int y = myDisc.y;
		if (direction == 1 || direction == 2 || direction == 3) {
			y --; //45 Grad,90 Grad,135 Grad
		} else if (direction == 5 || direction == 6 || direction == 7) {
			y ++;  //225 Grad,270 Grad,315 Grad
		}
		if (x < 0 || this.size <= x || y < 0 || this.size <= y) {
			//Wenn die Koordinaten außerhalb des Bereichs liegen
			return new Coordinates(-1, -1);
		}
		return new Coordinates(x, y);
	}

	//Akzeptiert Eingaben, bis die Größe des Othello-Boards festgelegt ist
	//Diese Methode ist der Konstruktor dafür.Wenn Sie es auf der rechten Seite der Größe einfügen,
	//Sie können einen Prozess hinzufügen, um die Größe der Othello-Karte einzugeben
	private int askBoardSize() {
		while (true) {
			System.out.println("");
			System.out.println("Bitte bestimmen Sie die Länge einer Seite des Othello-Boards.");
			System.out.print("[8, 10, 12, 14,Jeder von 16]：");
			Scanner sc = new Scanner(System.in);
			String line = sc.nextLine();
			if ("8".equals(line) || "10".equals(line) || "12".equals(line) ||
				"14".equals(line) || "16".equals(line)) {
				System.out.println("Die Länge einer Seite des Othello-Bretts beträgt" + line + "ist.");
				return Integer.parseInt(line);
			}
			System.out.println("Die Eingabe ist falsch.");
		}
	}

	//Akzeptiere die Eingabe, bis die Farbe des Spielers festgelegt ist
	private void askPlayerColor() {
		while (true) {
			System.out.println("\n Entscheide dich für deinen Stein.");
			System.out.println("[b (schwarz), w (Weiß)Irgendein von]：");
			Scanner sc = new Scanner(System.in);
			String line = sc.nextLine();
			if ("b".equals(line)) {
				System.out.println("Dein Stein ist schwarz.");
				this.playerColor = 'B';
				this.otherColor = 'W';
				return;
			} else if ("w".equals(line)) {
				System.out.println("Dein Stein ist weiß.");
				this.playerColor = 'W';
				this.otherColor = 'B';
				return;
			}
			System.out.println("Die Eingabe ist falsch.");
		}
	}

	//Zeigen Sie das Ergebnis des Spiels
	private void printResult() {
		if (playerDiscNum > otherDiscNum) {
			System.out.println("Du gewinnst.");
		} else if (playerDiscNum == otherDiscNum) {
			System.out.println("Es ist eine Zeichnung.");
		} else {
			System.out.println("Du verlierst.");
		}
	}

	//Zeigen Sie die Anzahl der Steine des Spielers und des Gegners an
	private void printDiscNumber() {
		this.playerDiscNum = this.countDisc(this.playerColor);
		this.otherDiscNum = this.countDisc(this.otherColor);
		System.out.print("Sie= " + playerDiscNum + "  ");
		System.out.println("Gegner= " + otherDiscNum);
	}

	//Zähle Steine der angegebenen Farbe
	private int countDisc(char myColor) {
		int count = 0;
		for (int y = 0; y < this.size; y ++) {
			for (int x = 0; x < this.size; x ++) {
				if (this.squares[y][x] == myColor) {
					count ++;
				}
			}
		}
		return count;
	}

	//Bringen Sie das Othello-Board sofort nach dem Start in den Zustand
	private void initializeBoard() {
		for (int y = 0; y < this.size; y ++) {
			for (int x = 0; x < this.size; x ++) {
				squares[y][x] = 'N';
			}
		}
		//Legen Sie Steine nur in die zentralen 4 Felder
		this.putDisc('B', this.size/2 - 1, this.size/2 - 1);
		this.putDisc('B', this.size/2, this.size/2);
		this.putDisc('W', this.size/2, this.size/2 - 1);
		this.putDisc('W', this.size/2 - 1, this.size/2);
	}

	//Platziere einen Stein an den angegebenen Koordinaten auf dem Othello-Brett
	private void putDisc(char discColor, int x, int y) {
		this.squares[y][x] = discColor;
	}
	private void putDisc(char discColor, Coordinates c) {
		this.putDisc(discColor, c.x, c.y);
	}

	//Zeige alle Koordinaten der umgedrehten Steine
	private void printDiscsTurnedOver(ArrayList<Coordinates> discs) {
		System.out.println("Ich drehte den nächsten Stein um.");
		int count = 0;
		for (int i = 0; i < discs.size(); i ++) {
			System.out.print(this.alphabets.substring(discs.get(i).x, discs.get(i).x + 1) +
				(discs.get(i).y + 1) + " ");
			count ++;
			if (count == 8) {
				System.out.println("");
				count = 0;
			}
		}
		System.out.println("");
	}

	//Zeigen Sie die Othello-Karte auf der Konsole an
	private void printBoard() {
		this.printBoardAlphabetLine();					//Alphabetzeile
		this.printBoardOtherLine("┏", "┳", "┓");		//Oberkante
		for (int y = 0; y < this.size - 1; y ++) {
			this.printBoardDiscLine(y);					//Linie, die Steine anzeigt
			this.printBoardOtherLine("┣", "╋", "┫");	//Zeilenabstand
		}
		this.printBoardDiscLine(this.size - 1);			//Linie, die Steine anzeigt
		this.printBoardOtherLine("┗", "┻", "┛");		//unteres Ende
	}

	//Zeigen Sie das Alphabet an, das die Zeile der Othello-Tafel angibt
	private void printBoardAlphabetLine() {
		String buf = "  ";
		for (int x = 0; x < this.size; x ++) {
			buf += "   " + this.alphabets.charAt(x);
		}
		System.out.println(buf);
	}

	//Zeigen Sie eine Linie mit Steinen auf dem Othello-Brett an
	private void printBoardDiscLine(int y) {
		String buf = String.format("%2d┃", y+1);
		for (int x = 0; x < this.size; x ++) {
			if (this.squares[y][x] == 'B') {
				buf += "●┃";
			} else if (this.squares[y][x] == 'W') {
				buf += "○┃";
			} else {
				buf += "　┃";
			}
		}
		System.out.println(buf);
	}

	//Zeigen Sie eine Linie von Linien an, die den Rahmen der Othello-Tafel darstellen
	private void printBoardOtherLine(String left, String middle, String right) {
		String buf = "  " + left;
		for (int x = 0; x < this.size - 1; x ++) {
			buf += "━" + middle;
		}
		System.out.println(buf + "━" + right);
	}
}

class Candidate extends Coordinates {
	public int priority;

	public Candidate(Coordinates c) {
		super(c);
	}
}

class Coordinates {
	public int x;
	public int y;

	Coordinates(int x, int y)  {
		this.x = x;
		this.y = y;
	}

	Coordinates(Coordinates c)  {
		this.x = c.x;
		this.y = c.y;
	}

	public void copy(Coordinates c) {
		this.x = c.x;
		this.y = c.y;
	}

	public boolean equals(int x, int y) {
		if (this.x == x && this.y == y) {
			return true;
		} else {
			return false;
		}
	}
}