function judge(state, phase_ref, next_phase) {
  for (let i = 0; i < state.conditions.length; ++i) {
    const condition = state.conditions[i];
    if (condition.is_met(state, phase_ref)) {
      state.next = next_phase;
      break;
    };
  }
  return state;
}

const phase_steps = {
  battle_start(state) {
    state.turns = 0;
    state.wt = 0;
    state.rounds = 0;
    state.round_wt = 0;
    state.round_mwt = 500; // choose a value of your liking or calculation
    state.entities.forEach((entity) => {
      // Notice that we 'set' the wt for battle start, instead of adding
      entity.wt = entity.mwt;
    });
    state.next = "round_next";
    return state;
  },
  round_next(state) {
    state.rounds += 1;
    state.next = "round_start";
    return state;
  },
  round_start(state) {
    state.entities.forEach((entity) => {
      entity.on_round_start();
    });
    state.next = "round_start_judge";
    return state;
  },
  round_start_judge(state) {
    // by default judging should immediately
    state.next = "tick_next";
    return judge(state, "round_start", "tick_next");
  },
  tick_next(state) {
    // be sure to unset the entity
    state.entity = null;
    // Instead of looping just to change the wt on the entities and state
    // Find the smallest wt in the entities and apply that to everything else
    // However the round_wt must not exceed it's maximum
    const smallest = state.entities.reduce((smallest_entity, entity) => {
      if (smallest_entity) {
        if (smallest_entity.wt > entity.wt) {
          return entity;
        } else {
          return smallest_entity;
        }
      } else {
        return entity;
      }
    }, null);
    if (smallest) {
      // set the applied to the smallest wt
      let applied_wt = smallest.wt;
      // add it to the round_wt to create expected round_wt
      let new_round_wt = state.round_wt + applied_wt;
      // check if the new round wt would exceed the maximum
      if (new_round_wt > state.round_mwt) {
        // if it did, applied must be changed to hit exactly the maximum
        applied_wt = state.round_mwt - state.round_wt;
        new_round_wt = state.round_mwt;
        state.next = "round_end"
      }
      state.entities.forEach((entity) => {
        entity.wt -= applied_wt;
      });
      state.round_wt = new_round_wt;
      if (smallest.wt === 0) {
        state.entity = smallest;
        state.next = "turn_start";
      }
    } else {
      // if it didn't find ANY entities, it simply means there was none to begin with, the battle should exit.
      // This could be quickly achieved by checking if there were any entities to begin with.
      state.next = "battle_end";
    }
    return state;
  },
  turn_start(state) {
    // here you can alert all entities that an entity's turn is starting
    // or you could just alert the entity alone, depends on if you need to alert everyone or not.
    state.entities.forEach((entity) => {
      // let the entity know that the specified entity is starting it's turn
      // if the entity being alerted matches the parameter, you may apply some special effects.
      entity.on_turn_start(state.entity);
    });
    // reset the entity's action index on turn start
    state.entity.action_index = 0;
    state.next = "turn_start_judge";
    return state;
  },
  turn_start_judge(state) {
    state.next = "action_next";
    return judge(state, "turn_start", "battle_end");
  },
  actions_next(state) {
    // determine if there are any available actions left
    if (state.entity.action_index < state.entity.action_max) {
      state.next = "actions_make";
    } else {
      state.next = "turn_end";
    }
    return state;
  },
  actions_make(state) {
    // this flag is set immediately for AIs but usually has to be set externally for players
    // Once they've made their action.
    if (state.entity.auto_action) {
      // make action should increment the action_index as needed
      state.entity.make_action();
      state.entity.action_ready = true;
    }
    if (state.entity.action_ready) {
      state.next = "action_start";
    }
    return state;
  },
  action_start(state) {
    if (state.entity.actions.length > 0) {
      state.entity.action = state.entity.actions.shift();
      state.next = "action_execute";
    } else {
      state.next = "actions_next";
    }
    return state;
  },
  action_execute(state) {
    if (state.entity.action) {
      // this can be executed outside of the state machine
      // only the action_completed flag needs to be set
    }

    if (state.entity.action.completed) {
      state.next = "action_end";
    }
    return state;
  },
  action_end(state) {
    // feel free to do anything here

    state.next = "action_judge";
    return state;
  },
  action_judge(state) {
    state.next = "actions_next";
    return judge(state, "action", "battle_end");
  },
  turn_end(state) {
    state.entities.forEach((entity) => {
      // let the entity know that the specified entity is starting it's turn
      // if the entity being alerted matches the parameter, you may apply some special effects.
      entity.on_turn_end(state.entity);
    });
    state.next = "turn_judge";
    return state;
  },
  turn_judge(state) {
    state.next = "tick_next";
    return judge(state, "turn", "battle_end");
  },
  round_end(state) {
    state.entities.forEach((entity) => {
      // let the entity know that the specified entity is starting it's turn
      // if the entity being alerted matches the parameter, you may apply some special effects.
      entity.on_round_end();
    });
    state.next = "round_end_judge";
    return state;
  },
  round_end_judge(state) {
    state.next = "round_next";
    return judge(state, "round", "battle_end");
  },
  battle_end(state) {
    // do whatever the hell you want to
    return state;
  },
  battle_end_judge(state) {
    // regardless of what happens, it should always end on finalize
    state.next = "finalize";
    return judge(state, "battle", "finalize");
  },
  finalize(state) {
    // do whatever the hell you want to
    return state;
  }
};

function run_phase(phase, state) {
  return phase_steps[phase](state);
}