#!/bin/bash -x

# bash game.sh [-n n] [-k k] [-s s] [-p1 x1,y1] [-p2 x2,y2] [-ai1 ai1] [-ai2 ai2]
#n – wielkość planszy (domyślnie 10);
#k – maksymalna liczba tur na gracza (domyślnie 100);
#s – czas w sekundach, przez który skrypt ma poczekać pomiędzy wiadomością END_TURN, a rozpoczęciem tury kolejnego gracza, aby interfejs graficzny nadążył z wyświetlaniem animacji (domyślnie 1);
#x1,y1 – początkowa pozycja króla pierwszego gracza (jeśli nie zostanie podana, to będzie wybrana losowo);
#x2,y2 – początkowa pozycja króla drugiego gracza (jeśli nie zostanie podana, to będzie wybrana losowo);
#ai1 – ścieżka do programu AI pierwszego gracza (jeśli nie zostanie podana, to przyjmuje się, że będzie nim człowiek);
#ai2 – ścieżka do programu AI drugiego gracza (jeśli nie zostanie podana, to przyjmuje się, że będzie nim człowiek).

# Initialize our own variables:
board_size=10
turns=100
wait_time=1
hum1=false
hum2=false
gui=./sredniowiecze_gui_with_libs.sh
#gui=../check_middle2/tests2/sredniowiecze_gui_with_libs.sh

function is_num () {
    if [[ $1 =~ ^-?[0-9]+$ ]]; then
        return 0
    else
        return 1
    fi
}

while [[ $# > 1 ]]
do
key="$1"

case ${key} in
    -n)
        if ! is_num $2; then
            exit 1
        fi
        board_size=$2
        shift
    ;;
    -k)
        if ! is_num $2; then
            exit 1
        fi
        turns=$2
        shift
    ;;
    -s)
        if ! is_num $2; then
            exit 1
        fi
        wait_time=$2
        shift
    ;;
    -p1)
        pos1="$2"
        shift
    ;;
    -p2)
        pos2="$2"
        shift
    ;;
    -ai1)
        ai1="$2"
        shift
    ;;
    -ai2)
        ai2="$2"
        shift
    ;;
    *)
        exit 1
    ;;
esac
shift
done

#echo board_size = "${board_size}"
#echo turns = "${turns}"
#echo wait_time = "${wait_time}"
#echo pos1 = "${pos1}"
#echo pos2 = "${pos2}"
#echo ai1 = "${ai1}"
#echo ai2 = "${ai2}"

function abs () {
    echo ${1#-}
}

function max () {
    echo $(( $1 > $2 ? $1 : $2 ))
}

function distance () {
    local x=$(abs $(( p1x - p2x )))
    local y=$(abs $(( p1y - p2y )))
    echo $(max x y)
}

function random () {
    echo $(shuf -i 1-$1 -n 1)
}

function can_place () {
    local x=$1
    local y=$2
    if [[ ($(( x - 8 )) -ge 1 || $(( x + 11 )) -le ${board_size}) && ($(( y - 8 )) -ge 1 || $(( y + 8 )) -le ${board_size}) ]]; then
        return 0
    else
        return 1
    fi
}

function out_board () {
    if [[ $1 -lt 1 || $1 -gt $((board_size - 3)) || $2 -lt 1 || $2 -gt ${board_size} ]]; then
        return 0
    else
        return 1
    fi
}

if [[ ${board_size} -le 8 ]]; then
    exit 1
fi

if [[ -z ${pos1+x} ]]; then
    if [[ -z ${pos2+x} ]]; then
#        echo "both unset"
        p1x=$(random $((board_size - 3)))
        p1y=1
        p2x=$(random $((board_size - 3)))
        p2y=${board_size}
    else
#        echo "first unset"
        IFS=\, read -a fields <<<"$pos2"
        p2x=${fields[0]}
        p2y=${fields[1]}
        if can_place ${p2x} ${p2y}; then
            while : ; do
                p1x=$(random $((board_size - 3)))
                p1y=$(random ${board_size})
                [[ $(distance) -lt 8 ]] || break
            done
        else
            exit 1
        fi
    fi
else
    if [[ -z ${pos2+x} ]]; then
#        echo "second unset"
        IFS=\, read -a fields <<<"$pos1"
        p1x=${fields[0]}
        p1y=${fields[1]}
        if can_place ${p1x} ${p1y}; then
            while : ; do
                p2x=$(random $((board_size - 3)))
                p2y=$(random ${board_size})
                [[ $(distance) -lt 8 ]] || break
            done
        else
            exit 1
        fi
    else
#        echo "both set"
        IFS=\, read -a fields <<<"$pos1"
        p1x=${fields[0]}
        p1y=${fields[1]}
        IFS=\, read -a fields <<<"$pos2"
        p2x=${fields[0]}
        p2y=${fields[1]}
        if [[ $(distance) -lt 8 ]]; then
            exit 1
        fi
    fi
fi

if [[ -z ${p1x} || -z ${p1y} || -z ${p2x} || -z ${p2y} ]]; then
    exit 1
fi

if out_board ${p1x} ${p1y} || out_board ${p2x} ${p2y}; then
    exit 1
fi

#echo p1 = "${p1x}, ${p1y}"
#echo p2 = "${p2x}, ${p2y}"

if [[ -z ${ai1+x} ]]; then
    hum1=true
else
    if [[ ! -x ${ai1} ]]; then
        exit 1
    fi
fi

if [[ -z ${ai2+x} ]]; then
    hum2=true
else
    if [[ ! -x ${ai2} ]]; then
        exit 1
    fi
fi


player1=true

if ${hum1} && ${hum2}; then
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 3<>${PIPE}
    rm ${PIPE}

    ${gui} -human1 -human2 <&3 >/dev/null & # >&4
    gui_pid=$!
    echo "INIT ${board_size} ${turns} 1 ${p1x} ${p1y} ${p2x} ${p2y}" >&3
    echo "INIT ${board_size} ${turns} 2 ${p1x} ${p1y} ${p2x} ${p2y}" >&3

    wait ${gui_pid}
elif ${hum1}; then
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 3<>${PIPE}
    rm ${PIPE}
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 4<>${PIPE}
    rm ${PIPE}
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 5<>${PIPE}
    rm ${PIPE}
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 6<>${PIPE}
    rm ${PIPE}

    ${gui} -human1 <&3 >&5 &
    gui_pid=$!
    ${ai2} <&4 >&6 &
    ai_pid=$!

    echo "INIT ${board_size} ${turns} 1 ${p1x} ${p1y} ${p2x} ${p2y}" >&3
    echo "INIT ${board_size} ${turns} 2 ${p1x} ${p1y} ${p2x} ${p2y}" >&4

    {
        while : ; do
            if ${player1}; then
                read msg <&5
                if [[ "$msg" == "END_TURN" ]]; then
                    player1=false
                fi
                echo "$msg" >&4
            else
                read msg <&6
                if [[ "$msg" == "END_TURN" ]]; then
                    player1=true
                fi
                echo "$msg" >&3
            fi
        done
    } &
    loop_pid=$!

    wait ${ai_pid}
    return_code=$?
    kill -KILL ${loop_pid}
    if [[ ${return_code} -ne 0 && ${return_code} -ne 1 && ${return_code} -ne 2 ]]; then
        exit 1
    fi
#    wait ${gui_pid}
#    if [[ $? -ne 0 ]]; then
#        exit 1
#    fi
elif ${hum2}; then
    exit 1
else
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 3<>${PIPE}
    rm ${PIPE}
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 4<>${PIPE}
    rm ${PIPE}
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 5<>${PIPE}
    rm ${PIPE}
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 6<>${PIPE}
    rm ${PIPE}
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 7<>${PIPE}
    rm ${PIPE}
    PIPE=$(mktemp -u)
    mkfifo ${PIPE}
    exec 8<>${PIPE}
    rm ${PIPE}

    ${ai1} <&3 >&6 &
    ai1_pid=$!
    ${ai2} <&4 >&7 &
    ai2_pid=$!
    ${gui} <&5 >&8 &
    gui_pid=$!

    echo "INIT ${board_size} ${turns} 1 ${p1x} ${p1y} ${p2x} ${p2y}" >&3 >&4 >&5
    echo "INIT ${board_size} ${turns} 2 ${p1x} ${p1y} ${p2x} ${p2y}" >&3 >&4 >&5

    while : ; do
        if ${player1}; then
            if kill -0 ${ai1_pid}; then
                read msg <&7
                if [[ "$msg" == "END_TURN" ]]; then
                    player1=false
                fi
                echo "$msg" >&4
                echo "$msg" >&5
            else
#                pkill -TERM -P ${ai_pid}
                break
            fi
        else
            if kill -0 ${ai2_pid}; then
                read msg <&5
                if [[ "$msg" == "END_TURN" ]]; then
                    player1=true
                fi
                echo "$msg" >&3
                echo "$msg" >&5
            else
                break
            fi
        fi
    done

    wait ${ai1_pid}
    return_code=$?
    if [[ ${return_code} -ne 0 && ${return_code} -ne 1 && ${return_code} -ne 2 ]]; then
        exit 1
    fi
    wait ${ai2_pid}
    return_code=$?
    if [[ ${return_code} -ne 0 && ${return_code} -ne 1 && ${return_code} -ne 2 ]]; then
        exit 1
    fi
fi