#include <iostream>

#include "Game.h"
#include "Types.h"

std::array<Vector, 8> Game::neighbours;
std::array<Vector, 9 * 5> Game::fieldVectors;

Game::Game() : active(-1, -1), direction(0, 0), lastLocation(0) {
    neighbours[0].set(1, 0);
    neighbours[1].set(0, 1);
    neighbours[2].set(-1, 0);
    neighbours[3].set(0, -1);
    neighbours[4].set(1, 1);
    neighbours[5].set(-1, 1);
    neighbours[6].set(1, -1);
    neighbours[7].set(-1, -1);

    uint index = 0;
    for(uint y = 0; y < 5; y++) {
        for(uint x = 0; x < 9; x++) {
            fieldVectors[index++].set(x, y);
        }
    }
}

void Game::print(String& s) const {
    s.append("\n\r  0 1 2 3 4 5 6 7 8\n\r");
    printLine(s, 0);
    s.append("  |\\|/|\\|/|\\|/|\\|/|\n\r");
    printLine(s, 1);
    s.append("  |/|\\|/|\\|/|\\|/|\\|\n\r");
    printLine(s, 2);
    s.append("  |\\|/|\\|/|\\|/|\\|/|\n\r");
    printLine(s, 3);
    s.append("  |/|\\|/|\\|/|\\|/|\\|\n\r");
    printLine(s, 4);
    s.append("\n\r");
}

void Game::printLine(String& s, int y) const {
    static const char map[] = {
        '#', 'O', '.'
    };
    s.append(y + '0').append(' ');
    for(int x = 0; x < 8; x++) {
        if(active.compare(x, y)) {
            s.append("*-");
            continue;
        }
        s.append(map[fields[x][y]]).append('-');
    }
    if(active.compare(8, y)) {
        s.append('*');
    } else {
        s.append(map[fields[8][y]]);
    }
    s.append("\n\r");
}

void Game::parse() {
    String s;
    while(true) {
        char c = std::cin.get();
        if(c == '0') {
            parseFields();
            continue;
        }
        if(c == '\n' || c == '\r') {
            std::cerr << s << "\n";
            s.clear();
            continue;
        }
        s.append(c);
        if(s == "select stone:") {
            std::cerr << s;
            s.clear();
            makeSelection();
        } else if(s == "select location to move:") {
            std::cerr << s;
            s.clear();
            makeMove();
        } else if(s == "select stone to take:") {
            std::cerr << s;
            s.clear();
            takeStone();
        }
    }
}

void Game::consumeLine() const {
    while(std::cin.get() != '\n');
    while(true) {
        char c = std::cin.peek();
        if(c != '\r') {
            break;
        }
        std::cin.get();
    }
}

void Game::consumeLine(uint y) {
    std::cin.get();
    std::cin.get();
    for(uint x = 0; x < 9; x++) {
        char c = std::cin.get();
        if(c == '#') {
            fields[x][y] = BLACK;
        } else if(c == '.') {
            fields[x][y] = EMPTY;
        } else if(c == 'O') {
            fields[x][y] = WHITE;
        } else if(c == '*') {
            active.set(x, y);
            fields[x][y] = WHITE;
        } else {
            std::cerr << "game field parsing error\n";
        }
        std::cin.get();
    }
}

void Game::parseFields() {
    for(uint i = 0; i < 5; i++) {
        consumeLine();
        consumeLine(i);
    }
    String s;
    print(s);
    std::cerr << s;
}

bool Game::isInRange(const Vector& v) const {
    return v.x >= 0 && v.x <= 8 && v.y >= 0 && v.y <= 4;
}

bool Game::areNeighbours(const Vector& from, const Vector& to) const {
    if(from == to) {
        return false;
    }
    Vector diff = from - to;
    if(diff.x < -1 || diff.x > 1 || diff.y < -1 || diff.y > 1) {
        return false;
    }
    if(diff.x == 0 || diff.y == 0) {
        return true;
    }
    return !((from.x & 1) ^ (from.y & 1));
}

void Game::removeLine(const Vector& from, const Vector& to, FieldState state) {
    Vector current = to;
    Vector diff = to - from;
    while(true) {
        current += diff;
        if(!isInRange(current) || !hasState(current, state)) {
            return;
        }
        setState(current, EMPTY);
    }
}

uint Game::getRank(const Vector& from, const Vector& to, FieldState state) const {
    Vector current = to;
    Vector diff = to - from;
    uint rank = 0;
    while(true) {
        current += diff;
        if(!isInRange(current) || !hasState(current, state)) {
            return rank;
        }
        rank++;
    }
}

void Game::addLocation(const Vector& v) {
    if(lastLocation < lastLocations.size()) {
        lastLocations[lastLocation] = v;
        lastLocation++;
    }
}

bool Game::isInQueue(const Vector& v) const {
    for(uint i = 0; i < lastLocation; i++) {
        if(lastLocations[i] == v) {
            return true;
        }
    }
    return false;
}

uint Game::getStoneTakes(const Vector& from, const Vector& to) const {
    if(!isInRange(to) || !hasState(to, EMPTY) || !areNeighbours(from, to) || isInQueue(to) || (to - from) == direction) {
        return 0;
    }
    FieldState enemy = (hasState(from, BLACK) ? WHITE : BLACK);
    uint rankA = getRank(from, to, enemy);
    uint rankB = getRank(to, from, enemy);
    if(rankA == 0 && rankB == 0) {
        return 0;
    }

    Game copy = *this;
    uint rank = 0;
    if(rankA >= rankB) {
        copy.removeLine(from, to, enemy);
        rank = rankA;
    } else {
        copy.removeLine(to, from, enemy);
        rank = rankB;
    }
    copy.addLocation(from);
    copy.move(from, to);

    uint maxRank = 0;
    for(Vector& m : neighbours) {
        uint rank = copy.getStoneTakes(to, to + m);
        if(rank > maxRank) {
            maxRank = rank;
        }
    }

    return rank + maxRank;
}

uint Game::getStoneFreedom(const Vector& from) const {
    if(hasState(from, EMPTY)) {
        return 0;
    }
    uint counter = 0;
    for(const Vector& m : neighbours) {
        Vector to = from + m;
        if(!isInRange(to) || !areNeighbours(from, to) || !hasState(to, EMPTY)) {
            continue;
        }
        counter++;
    }
    return counter;
}

uint Game::getFreedom(FieldState state) const {
    int sum = 0;
    for(const Vector& v : fieldVectors) {
        if(hasState(v, state)) {
            sum += getStoneFreedom(v);
        }
    }
    return sum;
}

bool Game::hasState(const Vector& v, FieldState state) const {
    return fields[v.x][v.y] == state;
}

Game::FieldState Game::getState(const Vector& v) const {
    return fields[v.x][v.y];
}

void Game::setState(const Vector& v, FieldState state) {
    fields[v.x][v.y] = state;
}

void Game::move(const Vector& from, const Vector& to) {
    direction = to - from;
    setState(to, getState(from));
    setState(from, EMPTY);
}

void Game::makeSelection() {
    lastLocation = 0;
    direction.set(0, 0);

    Vector selection(0, 0);
    int maxRank = -100000;
    for(Vector& to : fieldVectors) {
        if(!hasState(to, EMPTY)) {
            continue;
        }
        for(Vector& m : neighbours) {
            Vector from = to + m;
            if(!isInRange(from) || !hasState(from, WHITE) || !areNeighbours(from, to)) {
                continue;
            }
            int rank = getQuality(from, to);
            if(rank > maxRank) {
                maxRank = rank;
                selection = from;
            }
        }
    }
    std::cout << selection.x << " " << selection.y << "\n";
}

void Game::makeMove() {
    Vector maxTo(0, 0);
    int maxRank = -100000;
    for(Vector& m : neighbours) {
        Vector to = active + m;
        if(!isInRange(to) || !hasState(to, EMPTY) || isInQueue(to) || !areNeighbours(active, to) || m == direction) {
            continue;
        }
        if(lastLocation > 0) {
            int rank = getRank(active, to, BLACK) + getRank(to, active, BLACK);
            if(rank == 0) {
                continue;
            }
        }
        int rank = getQuality(active, to);
        if(rank > maxRank) {
            maxRank = rank;
            maxTo = to;
        }
    }
    addLocation(active);
    direction = maxTo - active;
    std::cerr << maxTo.x << " " << maxTo.y << "\n";
    std::cout << maxTo.x << " " << maxTo.y << "\n";
}

void Game::takeStone() {
    uint rankA = getRank(active, active + direction, BLACK);
    uint rankB = getRank(active + direction, active, BLACK);
    Vector v;
    if(rankA >= rankB) {
        v = active + direction + direction;
    } else {
        v = active - direction;
    }
    std::cout << v.x << " " << v.y << "\n";
}

int Game::getQuality(const Vector& from, const Vector& to) const {
    int quality = getStoneTakes(from, to);

    Game copy = *this;
    copy.move(from, to);
    uint rankA = copy.getRank(from, to, BLACK);
    uint rankB = copy.getRank(to, from, BLACK);
    if(rankA >= rankB) {
        copy.removeLine(from, to, BLACK);
    } else {
        copy.removeLine(to, from, BLACK);
    }
    copy.lastLocation = 0;
    copy.direction.set(0, 0);

    int whiteFreedom = copy.getFreedom(WHITE);
    int blackFreedom = copy.getFreedom(BLACK);

    int maxRank = -1;
    for(Vector& to : fieldVectors) {
        if(!copy.hasState(to, EMPTY)) {
            continue;
        }
        for(Vector& m : neighbours) {
            Vector from = to + m;
            if(!copy.isInRange(from) || !copy.hasState(from, BLACK)) {
                continue;
            }
            int rank = copy.getStoneTakes(from, to);
            if(rank > maxRank) {
                maxRank = rank;
            }
        }
    }

    int black = countBlack();
    if(black >= 8) {
        black = 1;
    }
    return quality - maxRank * black + (whiteFreedom - blackFreedom) / 4;
}

int Game::countBlack() const {
    int blackCounter = 0;
    for(Vector& v : fieldVectors) {
        blackCounter += hasState(v, BLACK);
    }
    return blackCounter;
}