/*
 * I love Qt
 */
#include "cell.h"
#include "units/unit.h"
#include <string>
#include <queue>
#include <vector>
#include <map>
#include <iostream>

class EffectsForCell{
public:
	void OperateOnCell(Cell*){}
};

Cell::Cell(Unit* character) {
	leftUp_ = left_ = leftDown_ = nullptr;
	rightUp_ = right_ = rightDown_ = nullptr;
	character_ = character;
	clearCell_();
	AddedToQuery_ = true;
	col_ = row_ = 0;
}

Cell * Cell::getleftUp() {
	return leftUp_;
}
void Cell::setleftUp(Cell * t) {
	leftUp_ = t;
}
Cell * Cell::getleft() {
	return left_;
}
void Cell::setleft(Cell * t) {
	left_ = t;
}
Cell * Cell::getleftDown() {
	return leftDown_;
}
void Cell::setleftDown(Cell * t) {
	leftDown_ = t;
}
Cell * Cell::getrightUp() {
	return rightUp_;
}
void Cell::setrightUp(Cell * t) {
	rightUp_ = t;
}
Cell * Cell::getright() {
	return right_;
}
void Cell::setright(Cell * t) {
	right_ = t;
}
Cell * Cell::getrightDown() {
	return rightDown_;
}
void Cell::setrightDown(Cell * t) {
	rightDown_ = t;
}
Unit * Cell::getCharacter() {
	return character_;
}
void Cell::setCharacter(Unit * t) {
	character_ = t;
}

int Cell::getdistance_barrier(){
    return distance_barrier_;
}
void Cell::setdistance_barrier(int distance_barrier){
    distance_barrier_ = distance_barrier;
}
int Cell::getdistance_through(){
    return distance_through_;
}
void Cell::setdistance_through(int distance_through){
    distance_through_ = distance_through;
}

bool Cell::getisMoveAble(){
    return isMoveAble_;
}
void Cell::setisMoveAble(bool isMoveAble){
    isMoveAble_ = isMoveAble;
}
bool Cell::getisMeleeAttackAble(){
    return isMeleeAttackAble_;
}
void Cell::setisMeleeAttackAble(bool isMeleeAttackAble){
    isMeleeAttackAble_ = isMeleeAttackAble;
}
bool Cell::getisRangeAttackAble(){
    return isRangeAttackAble_;
}
void Cell::setisRangeAttackAble(bool isRangeAttackAble){
    isRangeAttackAble_ = isRangeAttackAble;
}

bool Cell::isEmpty() {
	return character_ == nullptr;
}

void Cell::recalculateAllEffectsList(){
    for(std::vector<EffectsForCell*>::iterator it = beginIteratorEffectsList();
            it != endIteratorEffectsList();++it){
        (*it)->OperateOnCell(this);
    }
}
void Cell::add(EffectsForCell* effect){
    if(effect == nullptr)
        throw new int(228);
    effects_list_.push_back(effect);
}
void Cell::remove(std::vector<EffectsForCell*>::iterator it){
    if(beginIteratorEffectsList() <= it && it < endIteratorEffectsList()){
        effects_list_.erase(it);
    }
}
void Cell::remove(EffectsForCell* effect){
    for(std::vector<EffectsForCell*>::iterator it = beginIteratorEffectsList();
            it != endIteratorEffectsList();++it){
        if((*it) == effect){
            remove(it);
            return;
        }
    }
}
std::vector<EffectsForCell*>::iterator Cell::beginIteratorEffectsList(){
    return effects_list_.begin();
}
std::vector<EffectsForCell*>::iterator Cell::endIteratorEffectsList(){
    return effects_list_.end();
}

void Cell::RecalculateTableWithCenterThisPoint() {
    clearTable_();
    std::queue<Cell*> qWithUnMoveable;
    updateMoveableCells_(qWithUnMoveable);
    updateUnMovealeCells_(qWithUnMoveable);
}
std::vector <Cell*> Cell::actualPath(Cell* to) {
    if (!to || !to->getisMoveAble())return std::vector<Cell*>();
    auto ret = std::vector<Cell*>(1, to);
    while (to != this) {
        Cell * parent = nullptr;
        auto f = [&parent](Cell * TestParent, Cell * Now) {
            if (TestParent && TestParent->getdistance_barrier() + 1 == Now->getdistance_barrier()
                && TestParent->getisMoveAble()) {
                parent = TestParent;
            }
        };
        if(parent == nullptr) throw std::string("Don`t recalculated");
        f(to->getleftUp(), to);
        f(to->getleft(), to);
        f(to->getleftDown(), to);
        f(to->getrightUp(), to);
        f(to->getright(), to);
        f(to->getrightDown(), to);
        to = parent;
        ret.push_back(to);
    }
    return ret;
}

void Cell::clearCell_() {
    setdistance_barrier(-1);
    setdistance_through(-1);
    setisMeleeAttackAble(false);
    setisMoveAble(false);
    setisRangeAttackAble(false);
}

void Cell::clearTable_() {
	std::queue<Cell*> q;
	q.push(this);
	clearCell_();
	setdistance_through(0);
	this->AddedToQuery_ = false;
	auto f = [&q](Cell * t, Cell * parent, int delta_col, int delta_row) {
		if (t && t->AddedToQuery_ == true) {
			q.push(t);
			t->col_ = parent->col_ + delta_col;
			t->row_ = parent->row_ + delta_row;
			t->setdistance_through(
			        parent->getdistance_through() + 1
            );
			t->AddedToQuery_ = false;
		}
	};
	while (!q.empty()) {
		Cell * Now = q.front();
		q.pop();
		Now->clearCell_();
		f(Now->getleftUp(), Now, -1, 0);
		f(Now->getleft(), Now, 0, -1);
		f(Now->getleftDown(), Now, 1, -1);
		f(Now->getrightUp(), Now, -1, 1);
		f(Now->getright(), Now, 0, 1);
		f(Now->getrightDown(), Now, 1, 0);
	}
}

void Cell::recalcAttackable_(Cell * Now,bool isReached){
   /* if(Now == nullptr)return;
    if (!isEmpty() && !Now->isEmpty() &&
        getCharacter()->canAttackForDistance("Melee", Now->getdistance_barrier())
            ) {
        Now->setisMeleeAttackAble(isReached);
    }
    if (!isEmpty() && !Now->isEmpty() &&
        getCharacter()->canAttackForDistance("Range", Now->getdistance_barrier())
            ) {
        Now->setisRangeAttackAble(true);
    }*/
    return;
}

void Cell::recalcMoveable_(Cell * Now, bool isReached){
    if(Now == nullptr || Now->isEmpty() || isEmpty())return;
    Now->setisMoveAble(isReached);
}

void Cell::updateMoveableCells_(std::queue<Cell*> & Q) {
	std::queue<Cell*> q;
	q.push(this);
	setdistance_barrier(0);
	auto f = [&q, &Q](Cell * t, Cell * parent) {
		if (t && !t->AddedToQuery_) {
			t->AddedToQuery_ = true;
			if (t->getCharacter() != NULL) {
				Q.push(t);
				return;
			}
			q.push(t);
			t->setdistance_barrier(
			        parent->getdistance_barrier() + 1
            );
		}
	};
	while (!q.empty()) {
		Cell * Now = q.front();
		q.pop();
		recalcMoveable_(Now, true);
		recalcAttackable_(Now, true);

		f(Now->getleftUp(), Now);
		f(Now->getleft(), Now);
		f(Now->getleftDown(), Now);
		f(Now->getrightUp(), Now);
		f(Now->getright(), Now);
		f(Now->getrightDown(), Now);
	}
}

void Cell::updateUnMovealeCells_(std::queue<Cell*> & Q) {
	auto f = [&Q](Cell * t, Cell * parent) {
		if (t && !t->AddedToQuery_) {
			t->AddedToQuery_ = true;
			Q.push(t);
		}
	};
	while (!Q.empty()) {
		Cell * Now = Q.front();
		recalcMoveable_(Now, false);
		recalcAttackable_(Now, false);
		Q.pop();
		f(Now->getleftUp(), Now);
		f(Now->getleft(), Now);
		f(Now->getleftDown(), Now);
		f(Now->getrightUp(), Now);
		f(Now->getright(), Now);
		f(Now->getrightDown(), Now);
	}
}

Cell* Cell::getRealShootTarget(Cell* next){
	if(next == this){
		return next;
	}
	int next_col = next->col_;
	int next_row = next->row_;
	if(next_col - col_ == next_row - row_){//GoMainDiagonal
		if(next_col > col_){
			return getrightDown()->getright();
		}
		if(next_col < col_){
			return getleftUp()->getleft();
		}
		throw std::string("Don`t recalculated");
	}
	if(-2 * (next_col - col_) == (next_row - row_)){//GoSecondaryDiagonal
		if(next_col < col_){
			return getrightUp()->getright();
		}
		if(next_col > col_){
			return getleftDown()->getleft();
		}
		throw std::string("Don`t recalculated");
	}
	if(next_col - col_ == -2 * (next_row - row_)){//GoUp
		if(next_col < col_){
			return (getleftUp() != nullptr ? getleftUp()->getrightUp() : getrightUp()->getleftUp());
		}
		if(next_col > col_){
			return (getleftDown() != nullptr ? getleftDown()->getrightDown() : getrightDown()->getleftDown());
		}
		throw std::string("Don`t recalculated");
	}
	int row_secondary_diag = row_ - 2 * (next_col - col_);
	int row_main_diag = row_ + next_col - col_;
	int twice_row_up_line = 2 * row_ + col_ - next_col;
	if(next_col > col_){
		if(next_row < row_main_diag)return getleft();
		if(2 * next_row < twice_row_up_line)return getleftUp();
		if(next_row < row_secondary_diag)return getrightUp();
		return getright();
	}
	else{
		if(next_row < row_secondary_diag)return getleft();
		if(2 * next_row < twice_row_up_line)return getleftDown();
		if(next_row < row_main_diag)return getrightDown();
		return getright();
	}
}

void Cell::print(){
    return;
    //do nothing, need content
}
<html>
<head><title>PANIC: session(release): write data/sessions/f/8/f808b3a0c15388ac: no space left on device</title>
<meta charset="utf-8" />
<style type="text/css">
html, body {
	font-family: "Roboto", sans-serif;
	color: #333333;
	background-color: #ea5343;
	margin: 0px;
}
h1 {
	color: #d04526;
	background-color: #ffffff;
	padding: 20px;
	border-bottom: 1px dashed #2b3848;
}
pre {
	margin: 20px;
	padding: 20px;
	border: 2px solid #2b3848;
	background-color: #ffffff;
	white-space: pre-wrap;       /* css-3 */
	white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
	white-space: -pre-wrap;      /* Opera 4-6 */
	white-space: -o-pre-wrap;    /* Opera 7 */
	word-wrap: break-word;       /* Internet Explorer 5.5+ */
}
</style>
</head><body>
<h1>PANIC</h1>
<pre style="font-weight: bold;">session(release): write data/sessions/f/8/f808b3a0c15388ac: no space left on device</pre>
<pre>github.com/go-macaron/session@v0.0.0-20190805070824-1a3cdc6f5659/session.go:199 (0x8b2934)
gopkg.in/macaron.v1@v1.3.9/context.go:79 (0x83d0a0)
github.com/go-macaron/inject@v0.0.0-20160627170012-d8a0b8677191/inject.go:157 (0x80ab07)
github.com/go-macaron/inject@v0.0.0-20160627170012-d8a0b8677191/inject.go:135 (0x80a8a8)
gopkg.in/macaron.v1@v1.3.9/context.go:121 (0x83d1f8)
gopkg.in/macaron.v1@v1.3.9/context.go:112 (0x84fdb5)
gopkg.in/macaron.v1@v1.3.9/recovery.go:161 (0x84fda8)
gopkg.in/macaron.v1@v1.3.9/logger.go:40 (0x840c73)
github.com/go-macaron/inject@v0.0.0-20160627170012-d8a0b8677191/inject.go:157 (0x80ab07)
github.com/go-macaron/inject@v0.0.0-20160627170012-d8a0b8677191/inject.go:135 (0x80a8a8)
gopkg.in/macaron.v1@v1.3.9/context.go:121 (0x83d1f8)
gopkg.in/macaron.v1@v1.3.9/router.go:187 (0x850fc6)
gopkg.in/macaron.v1@v1.3.9/router.go:303 (0x8493e5)
gopkg.in/macaron.v1@v1.3.9/macaron.go:220 (0x841fca)
net/http/server.go:2836 (0x7a79b2)
net/http/server.go:1924 (0x7a341b)
runtime/asm_amd64.s:1373 (0x46f9f0)
</pre>
</body>
</html>