sdadad

import math
from functools import reduce
import numpy
import json

initial_state = {
    "state": [3, 3, 0, 0],
    "prev": [],
    "distanceH": 0,
    "boat": 0,
}

final_state = {
    "state": [0, 0, 3, 3],
    "prev": [],
}

possibilities = [
    [1, 0],
    [0, 1],
    [2, 0],
    [0, 2],
    [1, 1],
]


def resolveDeslocament(state, possibility):
    missionariesLeft = state.get("state")[0]

    cannibalsLeft = state.get("state")[1]

    missionariesRight = state.get("state")[2]
    cannibalsRight = state.get("state")[3]

    numOfMissionariesLeft = 0
    numOfCannibalsLeft = 0

    numOfMissionariesRight = 0
    numOfCannibalsRight = 0

    if state.get("boat") == 0:
        if possibility[0] > missionariesLeft or possibility[1] > cannibalsLeft:
            return
        numOfMissionariesLeft = missionariesLeft - possibility[0]
        numOfCannibalsLeft = cannibalsLeft - possibility[1]
        numOfMissionariesRight = missionariesRight + possibility[0]
        numOfCannibalsRight = cannibalsRight + possibility[1]
    else:
        if possibility[0] > missionariesRight or possibility[1] > cannibalsRight:
            return
        numOfMissionariesLeft = missionariesLeft + possibility[0]
        numOfCannibalsLeft = cannibalsLeft + possibility[1]
        numOfMissionariesRight = missionariesRight - possibility[0]
        numOfCannibalsRight = cannibalsRight - possibility[1]

    invalidLeft = numOfMissionariesLeft < numOfCannibalsLeft and numOfMissionariesLeft != 0
    invalidRight = numOfCannibalsRight < numOfMissionariesRight and numOfCannibalsRight != 0

    if (invalidLeft or invalidRight):
        return

    new_state = [
        numOfMissionariesLeft,
        numOfCannibalsLeft,
        numOfMissionariesRight,
        numOfCannibalsRight,
    ]

    if state.get("boat") == 0:
        side = 1
    else:
        side = 0

    data = {
        "state": new_state,
        "prev": state,
        "distanceH": None,
        "boat": side,
    }
    print("DATA", data)
    return data


def calculateDistEuc(arrX, arrY):
    sumValues = []
    dist = math.dist(arrX, arrY)  # calculo euclidiano
    sumValues.append(dist)
    sum = reduce(lambda x, y: x + y, sumValues)
    return sum


def main(currentState):
    if(currentState.get("state") == final_state.get("state")):
        return

    deslocaments = []
    for possibility in possibilities:
        deslocament = resolveDeslocament(currentState, possibility)
        if deslocament != None:
            deslocaments.append(deslocament)

    if len(deslocaments) == 0:
        main(currentState.get("prev"))
        return

    minValueState = {}
    minValue = 0
    distanceH = 0
    distanceG = 0

    for idx in deslocaments:
        distanceH = calculateDistEuc(
            idx.get("state"), currentState.get("state"))
        distanceG = calculateDistEuc(
            final_state.get("state"), idx.get("state"))
        totalDist = distanceH + distanceG
        if idx == 0:
            minValue = totalDist
            minValueState = deslocaments[idx]
        if totalDist < minValue:
            minValue = totalDist
            minValueState = deslocaments[idx]
        minValueState["distanceH"] = distanceH
    return


main(initial_state)