chill-bundles/src/Bundle/ChillPersonBundle/Resources/public/vuejs/<

import { createStore } from 'vuex';
import { householdMove, fetchHouseholdSuggestionByAccompanyingPeriod, fetchAddressSuggestionByPerson} from './../api.js';
import { datetimeToISO } from 'ChillMainAssets/chill/js/date.js';

const debug = process.env.NODE_ENV !== 'production';

const concerned = window.household_members_editor_data.persons.map(p => {
  return {
    person: p,
    position: null,
    allowRemove: false,
    holder: false,
    comment: "",
  };
});

console.log('expand suggestions', window.household_members_editor_expand_suggestions === 1);

const store = createStore({
  strict: debug,
  state: {
    concerned,
    household: window.household_members_editor_data.household,
    positions: window.household_members_editor_data.positions.sort((a, b) => {
        if (a.ordering < b.ordering) {
          return -1;
        }
        if (a.ordering > b.ordering) {
          return 1;
        }
        return 0;
      }),
    startDate: new Date(),
    allowHouseholdCreate: window.household_members_editor_data.allowHouseholdCreate,
    allowHouseholdSearch: window.household_members_editor_data.allowHouseholdSearch,
    allowLeaveWithoutHousehold: window.household_members_editor_data.allowLeaveWithoutHousehold,
    forceLeaveWithoutHousehold: false,
    householdSuggestionByAccompanyingPeriod: [],
    showHouseholdSuggestion: window.household_members_editor_expand_suggestions === 1,
    addressesSuggestion: [],
    warnings: [],
    errors: []
  },
  getters: {
    isHouseholdNew(state) {
      if (state.household === null) {
        return false;
      }
      return !Number.isInteger(state.household.id);
    },
    hasHousehold(state) {
      return state.household !== null;
    },
    hasHouseholdOrLeave(state) {
      return state.household !== null || state.forceLeaveWithoutHousehold;
    },
    hasHouseholdSuggestion(state, getters) {
      return getters.filterHouseholdSuggestionByAccompanyingPeriod.length > 0;
    },
    countHouseholdSuggestion(state, getters) {
      return getters.filterHouseholdSuggestionByAccompanyingPeriod.length;
    },
    filterHouseholdSuggestionByAccompanyingPeriod(state) {
      if (state.household === null) {
        return state.householdSuggestionByAccompanyingPeriod;
      }

      return state.householdSuggestionByAccompanyingPeriod
        .filter(h => h.id !== state.household.id)
        ;
    },
    hasPersonsWellPositionnated(state, getters) {
      return getters.needsPositionning === false
        || (getters.persons.length > 0 && getters.concUnpositionned.length === 0);
    },
    persons(state) {
      return state.concerned.map(conc => conc.person);
    },
    concUnpositionned(state) {
      return state.concerned
        .filter(conc => conc.position === null)
      ;
    },
    positions(state) {
      return state.positions;
    },
    personByPosition: (state) => (position_id) => {
      return state.concerned
        .filter(conc =>
          conc.position !== null ? conc.position.id === position_id : false
        )
        .map(conc => conc.person)
      ;
    },
    concByPosition: (state) => (position_id) => {
      return state.concerned
        .filter(conc =>
          conc.position !== null ? conc.position.id === position_id : false
        )
      ;
    },
    concByPersonId: (state) => (person_id) => {
      return state.concerned
        .find(conc => conc.person.id === person_id)
      ;
    },
    needsPositionning(state) {
      return state.forceLeaveWithoutHousehold === false;
    },
    buildPayload: (state) => {
      let
        conc,
        payload_conc,
        payload = {
          concerned: [],
          destination: null
        }
      ;

      if (state.forceLeaveWithoutHousehold === false) {
        payload.destination = {
            id: state.household.id,
            type: state.household.type
          };
      }

      for (let i in state.concerned) {
        conc = state.concerned[i];
        payload_conc = {
          person: {
            id: conc.person.id,
            type: conc.person.type
          },
          start_date: {
            datetime: datetimeToISO(state.startDate)
          }
        };

        if (state.forceLeaveWithoutHousehold === false) {
          payload_conc.position = {
            id: conc.position.id,
            type: conc.position.type
          };
          payload_conc.holder = conc.holder;
          payload_conc.comment = conc.comment;
        }

        payload.concerned.push(payload_conc);
      }

      return payload;
    },
  },
  mutations: {
    addConcerned(state, person) {
      let persons = state.concerned.map(conc => conc.person.id);
      if (!persons.includes(person.id)) {
        state.concerned.push({
          person,
          position: null,
          allowRemove: true,
          holder: false,
          comment: "",
        });
      } else {
        console.err("person already included");
      }
    },
    markPosition(state, { person_id, position_id}) {
      let
        position = state.positions.find(pos => pos.id === position_id),
        conc = state.concerned.find(c => c.person.id === person_id);
      conc.position = position;
    },
    setComment(state, {conc, comment}) {
      conc.comment = comment;
    },
    toggleHolder(state, conc) {
      conc.holder = !conc.holder;
    },
    removePosition(state, conc) {
      conc.holder = false;
      conc.position = null;
    },
    removeConcerned(state, conc) {
      state.concerned = state.concerned.filter(c =>
        c.person.id !== conc.person.id
      )
    },
    createHousehold(state) {
      state.household = { type: 'household', members: [], current_address: null, 
        current_members_id: [] };
      state.forceLeaveWithoutHousehold = false;
    },
    removeHousehold(state) {
      state.household = null;
      state.forceLeaveWithoutHousehold = false;
    },
    setHouseholdAddress(state, address) {
      if (null === state.household) {
        console.error("no household");
        throw new Error("No household");
      }

      state.household.current_address = address;
      state.household.force_new_address = address;
    },
    forceLeaveWithoutHousehold(state) {
      state.household = null;
      state.forceLeaveWithoutHousehold = true;
    },
    selectHousehold(state, household) {
      state.household = household;
      state.forceLeaveWithoutHousehold = false;
    },
    setHouseholdSuggestionByAccompanyingPeriod(state, households) {
      let existingIds = state.householdSuggestionByAccompanyingPeriod
        .map(h => h.id);
      for (let i in households) {
        if (!existingIds.includes(households[i].id)) {
          state.householdSuggestionByAccompanyingPeriod.push(households[i]);
        }
      }
    },
    setStartDate(state, dateI) {
      state.startDate = dateI;
    },
    toggleHouseholdSuggestion(state) {
      state.showHouseholdSuggestion = !state.showHouseholdSuggestion;
    },
    setWarnings(state, warnings) {
      state.warnings = warnings;
      // reset errors, which should come from servers
      state.errors.splice(0, state.errors.length);
    },
    setErrors(state, errors) {
      state.errors = errors;
    },
    addAddressesSuggestion(state, addresses) {
      let existingIds = state.addressesSuggestion
        .map(a => a.id);

      for (let i in addresses) {
        if (!existingIds.includes(addresses[i].id)) {
          state.addressesSuggestion.push(addresses[i]);
        }
      }
    }
  },
  actions: {
    addConcerned({ commit, dispatch }, person) {
      commit('addConcerned', person);
      dispatch('computeWarnings');
      dispatch('fetchAddressSuggestions');
    },
    markPosition({ commit, state, dispatch }, { person_id, position_id }) {
      commit('markPosition', { person_id, position_id });
      dispatch('computeWarnings');
    },
    toggleHolder({ commit, dispatch }, conc) {
      commit('toggleHolder', conc);
      dispatch('computeWarnings');
    },
    removePosition({ commit, dispatch }, conc) {
      commit('removePosition', conc);
      dispatch('computeWarnings');
    },
    removeConcerned({ commit, dispatch }, conc) {
      commit('removeConcerned', conc);
      dispatch('computeWarnings');
      dispatch('fetchAddressSuggestions');
    },
    removeHousehold({ commit, dispatch }) {
      commit('removeHousehold');
      dispatch('computeWarnings');
    },
    createHousehold({ commit, dispatch }) {
      commit('createHousehold');
      dispatch('computeWarnings');
    },
    forceLeaveWithoutHousehold({ commit, dispatch }) {
      commit('forceLeaveWithoutHousehold');
      dispatch('computeWarnings');
    },
    selectHousehold({ commit }, h) {
      commit('selectHousehold', h);
      dispatch('computeWarnings');
    },
    setStartDate({ commit, dispatch }, date) {
      commit('setStartDate', date);
      dispatch('computeWarnings');
    },
    setComment({ commit }, payload) {
      commit('setComment', payload);
    },
    fetchHouseholdSuggestionForConcerned({ commit, state }, person) {
      fetchHouseholdSuggestionByAccompanyingPeriod(person.id)
        .then(households => {
          commit('setHouseholdSuggestionByAccompanyingPeriod', households);
        });
    },
    fetchAddressSuggestions({ commit, state }) {
      for (let i in state.concerned) {
        fetchAddressSuggestionByPerson(state.concerned[i].person.id)
          .then(addresses => {
            commit('addAddressesSuggestion', addresses);
          })
          .catch(e => {
            console.log(e);
          });
      }
    },
    computeWarnings({ commit, state, getters }) {
      let warnings = [],
        payload;

      if (!getters.hasHousehold && !state.forceLeaveWithoutHousehold) {
        warnings.push({ m: 'household_members_editor.add_destination', a: {} });
      }

      if (state.concerned.length === 0) {
        warnings.push({ m: 'household_members_editor.add_at_least_onePerson', a: {} });
      }

      if (getters.concUnpositionned.length > 0
        && !state.forceLeaveWithoutHousehold) {
        warnings.push({ m: 'household_members_editor.give_a_position_to_every_person', a: {} })
      }

      commit('setWarnings', warnings);
    },
    confirm({ getters, state, commit }) {
      let payload = getters.buildPayload,
        errors = [],
        person_id,
        household_id,
        error
      ;

        householdMove(payload).then(household => {
          if (household === null) {
            person_id = getters.persons[0].id;
            window.location.replace(`/fr/person/${person_id}/general`);
          } else {
            if (household.type === 'household') {
              household_id = household.id;
              // nothing to do anymore here, bye-bye !
              window.location.replace(`/fr/person/household/${household_id}/summary`);
            } else {
              // we assume the answer was 422...
              error = household;
              for (let i in error.violations) {
                let e = error.violations[i];
                errors.push(e.title);
              }

              commit('setErrors', errors);
            }
          }
      });
    },
  }
});

store.dispatch('computeWarnings');
store.dispatch('fetchAddressSuggestions');

if (concerned.length > 0) {
  concerned.forEach(c => {
    store.dispatch('fetchHouseholdSuggestionForConcerned', c.person);
  });
}

export { store };