import moment from 'moment';
import { compose, mapTo, mapFrom } from 'functional-functions';
import actions from './actions';
import { del, putChanged, postChanged, getChanged, responseIsJson } from '../../../server-com';
import { FormValue } from '../../dataTypes';
import {
  validateEditPayoutBankItem,
  isEditPayoutBankFormValid,
  validateEditPayoutCustomerItem,
  isEditPayoutCustomerFormValid,
  validateEditPayoutBrokerItem,
  isEditPayoutBrokerFormValid,
  validateEditPayoutInternalItem,
  isEditPayoutInternalFormValid,
  isTotalPayoutSumValid
} from './validation';
import { filterPayouts, sum } from './payout-functions';
import { showModalNewPayout } from '../modal';
import { eMailFormOperations } from './';


const validatePayoutMap = {
  name: 'bankName',
  accountNumber: 'accountNumber',
  amount: 'amount',
  loanContractNumber: 'loanContractNumber',
  kid: 'kidNumber',
  postalNumber: 'bankPostalNumber',
  email: 'bankEmail'
};

const payoutMap = {
  id: 'id',
  idForProposal: 'idForProposal',
  payoutType: 'payoutType',
  type: 'type',
  paymentInfo: 'informationText',
  address: 'bankAddress',
  location: 'bankLocation',
  payoutDate: 'payoutDate',
  isProposal: 'isProposal',
  documentId: 'documentId',
  includePayout: 'includePayout',
  isCredit: 'isCredit',
  ...validatePayoutMap
};

const validateFor = type => state => value => ({
  external: (v, s) => validateEditPayoutBankItem(v, s),
  customer: (v, s) => validateEditPayoutCustomerItem(v, s),
  broker: (v, s) => validateEditPayoutBrokerItem(v, s),
  internal: (v, s) => validateEditPayoutInternalItem(v, s)
}[type](value, state));

const isValidFor = type => state => value => ({
  customer: (v, s) => isEditPayoutCustomerFormValid(v, s),
  external: (v, s) => isEditPayoutBankFormValid(v, s),
  broker: (v, s) => isEditPayoutBrokerFormValid(v, s),
  internal: (v, s) => isEditPayoutInternalFormValid(v, s)
}[type](value, state));

const validateForm = () => (dispatch, getState) => {
  const { payouts } = getState();
  const { form } = payouts;
  const { type } = form;
  const isValid = isValidFor(type)(payouts);

  dispatch(actions.setFormValidity(isValid(getState().payouts.form.data)));
};

const validateItem = id => (dispatch, getState) => {
  const { payouts } = getState();
  const { form } = payouts;
  const { type } = form;
  const value = form.data[id];
  const validate = validateFor(type)(payouts);

  if (value) {
    dispatch(actions.changePayout(id, validate(value)));
  }
};

const matchWithRecipient = (payout, banks) =>
  ((payout.isProposal && payout.name)
    ? banks.find(b => b.name.trim().toLowerCase() === payout.name.trim().toLowerCase())
    : null);

const toPayouts = ({ payouts, payoutDate, payoutBufferAmount, productId }) => ({ payouts: payouts.map(mapFrom(payoutMap)), payoutDate, payoutBufferAmount, productId });

const newPayoutOnServer = () => (dispatch, getState) => {
  dispatch(actions.writeErrorMessage(''));
  const { newPayoutUrl, payouts } = getState().payouts;
  const errorMessage = 'Noe gikk galt ved opprettelse av ny utbetaling';
  const payout = payouts.find(p => p.id === null);
  const payoutToSend = mapTo(payoutMap)(payout);

  const errorHandler = error => dispatch(actions.writeErrorMessage(`\n ${errorMessage}: ${error}`));

  postChanged(newPayoutUrl, payoutToSend)
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        Promise.all([
          dispatch(actions.serverUpdated(response.id))
        ])
          .then(() => dispatch(actions.updateViewModel()));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

const updatePayoutOnServer = id => (dispatch, getState) => {
  dispatch(actions.writeErrorMessage(''));
  const { updatePayoutUrl, payouts } = getState().payouts;
  const errorMessage = 'Noe gikk galt ved oppdatering av utbetalinger';
  const payout = payouts.find(p => p.id === id);

  const errorHandler = error => dispatch(actions.writeErrorMessage(`\n ${errorMessage}: ${error}`));

  putChanged(updatePayoutUrl, mapTo(payoutMap)(payout))
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        Promise.all([
          dispatch(actions.serverUpdated(response.id))
        ])
          .then(() => dispatch(actions.updateViewModel()));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

const updateServer = id => (dispatch) => {
  dispatch(actions.updatingServer());

  return (!id) ? dispatch(newPayoutOnServer()) : dispatch(updatePayoutOnServer(id));
};

const deleteFromServer = id => (dispatch, getState) => {
  dispatch(actions.writeErrorMessage(''));
  dispatch(actions.deletingFromServer(id));
  const errorMessage = 'Noe gikk galt ved sletting av utbetalinger';
  const { deletePayoutUrl } = getState().payouts;
  const deletionUrl = `${deletePayoutUrl}/${id}`;

  const successHandler = () => {
    Promise.all([
      dispatch(actions.payoutDeleted)
    ])
      .then(() => dispatch(actions.updateViewModel()));
  };
  const errorHandler = error => dispatch(actions.deletePayoutFailed(`\n ${errorMessage}: Feilkode av type ${error} feil vart returnert`));

  return del(deletionUrl)
    .then((response) => {
      if (!response.ok) throw new Error(response.status);
    })
    .then(successHandler, errorHandler);
};


const getRecipients = () => (dispatch, getState) => {
  dispatch(actions.fetchingRecipients());
  const errorMessage = 'Noe gikk galt ved uthenting av mottaker for utbetalinger';
  const { getRecipientsUrl } = getState().payouts;
  const errorHandler = error => dispatch(actions.getRecipientsFailed(`\n ${errorMessage}: ${error}`));

  getChanged(getRecipientsUrl)
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        dispatch(actions.getRecipientsReceived(response));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

const updateCustomerPayout = () => (dispatch, getState) => {
  const { payouts, loanAmount, registrationFee, registrationFeeInLoanAmount } = getState().payouts;

  const payoutsExceptCustomer = payouts.filter(p => p.type !== 'customer');
  const { actualPayouts, newPayouts } = filterPayouts(payoutsExceptCustomer);

  const sumPayouts = [...actualPayouts, ...newPayouts].reduce(sum, 0.0);
  const rest = loanAmount - (registrationFeeInLoanAmount ? 0.0 : registrationFee) - sumPayouts;
  const toCustomer = rest < 0 ? 0.0 : rest;

  // Possibly add support for multiple accounts

  dispatch(actions.updateCustomerAmount(toCustomer));
};

const updatePayoutAmount = () => (dispatch, getState) => {
  const { payouts, registrationFee, registrationFeeInLoanAmount } = getState().payouts;

  const onlyActualPayouts = p => !p.isProposal;

  const payoutAmount = payouts.filter(onlyActualPayouts).reduce(sum, registrationFeeInLoanAmount ? 0.0 : registrationFee);

  dispatch(actions.updatePayoutAmount(payoutAmount));
};

const maybeResetCustomerPayout = type => (dispatch, getState) => {
  if (type && type === 'customer') return Promise.resolve();

  const { payouts } = getState().payouts;
  const customerPayout = payouts.find(p => p.type === 'customer' && !p.isProposal);

  if (customerPayout) {
    dispatch(actions.deletePayout(customerPayout.id));
    return dispatch(deleteFromServer(customerPayout.id))
      .then(() => dispatch(updatePayoutAmount()));
  }

  return Promise.resolve();
};

const getAccountNumbers = () => (dispatch, getState) => {
  dispatch(actions.fetchingCustomerAccounts());
  const errorMessage = 'Noe gikk galt ved henting av kontonummer';
  const { getCustomerAccountsUrl } = getState().payouts;
  const successHandler = response => dispatch(actions.customerAccountsReceived(response));
  const errorHandler = error => dispatch(actions.getCustomerAccountsFailed(`\n ${errorMessage}: ${error}`));

  getChanged(getCustomerAccountsUrl)
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        dispatch(successHandler(response));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

const maybeGetAccountNumbers = type => (dispatch, getState) => {
  if (type !== 'customer') return Promise.resolve();

  const { customerAccountNumbers } = getState().payouts;
  if (customerAccountNumbers && customerAccountNumbers.length > 0) return Promise.resolve();

  return dispatch(getAccountNumbers());
};

const canSendToPostControlCheck = () => (dispatch, getState) => {
  dispatch(actions.writeValidateMessage(''));
  const
    { payouts,
      loanAmount,
      registrationFeeInLoanAmount,
      registrationFee,
      payoutDate,
      payoutBufferAmount,
      productId,
      buttonStates,
      applicationCurrentState } = getState().payouts;

  let canSend = false;
  const currentState = applicationCurrentState ? applicationCurrentState === 'S017' : false;

  if (currentState) {
    const onlyActualPayouts = p => !p.isProposal;
    const actualPayouts = payouts.filter(onlyActualPayouts);
    const isActualPayouts = actualPayouts && actualPayouts.length > 0;
    const sumPayouts = actualPayouts.reduce(sum, registrationFeeInLoanAmount ? 0.0 : registrationFee);
    const payoutSumOk = isTotalPayoutSumValid(sumPayouts, loanAmount, payoutBufferAmount, productId);
    const dateOk = payoutDate ? moment(payoutDate) >= moment().startOf('day') : false;
    const datesAreEqual = (actualPayouts && payoutDate) ? actualPayouts.every(p => new Date(p.payoutDate).getTime() === payoutDate.getTime()) : false;
    const buttonStateTilEtterkontrollErrorMessage = buttonStates ? buttonStates.find(b => b.name === 'Til etterkontroll').message : '';

    canSend = isActualPayouts && payoutSumOk && dateOk && datesAreEqual && buttonStateTilEtterkontrollErrorMessage === '';

    if (isActualPayouts) {
      if (!canSend) {
        const errorMsg = `\n Kan ikke gå videre til etterkontroll: ${!payoutSumOk ? '\n Det er ikke korrekt utbetalingsum.' : ''} ${!dateOk ? '\n Det er ikke mulig å sette opp utbetalinger med dato tilbake i tid.' : ''} ${!datesAreEqual ? '\n Utbetalingsdatoen må være lik for alle utbetalinger.' : ''} ${buttonStateTilEtterkontrollErrorMessage !== '' ? `\n ${buttonStateTilEtterkontrollErrorMessage}` : ''}`;
        dispatch(actions.writeValidateMessage(errorMsg));
      }
    }
  }
  return dispatch(actions.canSendToPostControl(canSend));
};


const getBankHolidays = () => (dispatch, getState) => {
  dispatch(actions.fetchingBankHolidays());
  const errorMessage = 'Noe gikk galt ved henting av mulige utbetalingsdatoer';
  const { getBankHolidaysUrl } = getState().payouts;
  const errorHandler = error => dispatch(actions.getBankHolidaysFailed(`\n ${errorMessage}: ${error}`));

  getChanged(getBankHolidaysUrl)
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        dispatch(actions.bankHolidaysReceived(response));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

const getButtonStates = () => (dispatch, getState) => {
  dispatch(actions.fetchingButtonStates());
  const errorMessage = 'Noe gikk galt ved henting av status for mulig funksjonalitet for utbetalinger';
  const { getButtonStatesUrl } = getState().payouts;
  const successHandler = response => dispatch(actions.buttonStatesReceived(response));
  const errorHandler = error => dispatch(actions.getButtonStatesFailed(`\n ${errorMessage}: ${error}`));

  getChanged(getButtonStatesUrl)
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        dispatch(successHandler(response));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

const getLetterOfPaymentCustomer = () => (dispatch, getState) => {
  const { getLetterOfPaymentCustomerUrl } = getState().payouts;
  const successHandler = response => dispatch(actions.letterOfPaymentCustomerReceived(response));
  getChanged(getLetterOfPaymentCustomerUrl)
    .then(
      (response) => {
        successHandler(response);
      },
      () => {} // No error-handling required
    );
};

const getPayouts = () => (dispatch, getState) => {
  dispatch(actions.fetchingPayouts());
  const errorMessage = 'Noe gikk galt ved henting av utbetalinger';
  const { getPayoutsUrl } = getState().payouts;
  const successHandler = response => dispatch(actions.payoutsReceived(toPayouts(response)));
  const errorHandler = error => dispatch(actions.getPayoutsFailed(`\n ${errorMessage}: ${error}`));

  getChanged(getPayoutsUrl)
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        Promise.all([
          dispatch(successHandler(response))
        ])
          .then(() => dispatch(updateCustomerPayout()))
          .then(() => dispatch(updatePayoutAmount()))
          .then(() => dispatch(canSendToPostControlCheck()))
          .then(() => dispatch(getBankHolidays()))
          .then(() => dispatch(actions.updateViewModel()));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

/*-------------------------------------------------------------------*/

const initPayouts = props => (dispatch) => {
  const { proxy, ...rest } = props; // Proxy comes from habitat
  dispatch(actions.initPayouts(rest));

  return Promise.all([
    dispatch(getPayouts()),
    dispatch(getButtonStates()),
    dispatch(getLetterOfPaymentCustomer())
  ])
    .then(() => dispatch(actions.payoutsInitialized()));
};

const newPayout = () => (dispatch, getState) => {
  dispatch(getRecipients());
  const { newPayoutType } = getState().payouts;

  const selectType = (type) => {
    dispatch(actions.newPayout(type));
    dispatch(actions.showForm());
    return dispatch(maybeGetAccountNumbers(type));
  };

  return showModalNewPayout(
    dispatch,
    'Velg type',
    {
      external: 'Bank',
      internal: 'Intern',
      broker: 'Megler/Annen part',
      customer: 'Kunde'
    },
    newPayoutType,
    selectType
  );
};

const editPayout = id => (dispatch, getState) => {
  dispatch(getRecipients());
  const { payouts, banks, brokers } = getState().payouts;
  const payout = payouts.find(p => p.id === id);
  const getRecipient = () => {
    const registers = {
      external: banks,
      broker: brokers
    };
    const register = registers[payout.type];
    return register ? matchWithRecipient(payout, register) : null;
  };
  const recipient = getRecipient();

  dispatch(actions.editPayout(id));
  if (recipient) dispatch(actions.selectRecipient(recipient.id)); // Can do this by id to make more performant.. Would need a new action then.
  dispatch(actions.showForm());
  return Promise.all([
    dispatch(maybeGetAccountNumbers(payout.type))])
    .then(() => dispatch(validateForm()));
};

const changePayout = (id, value) => (dispatch) => {
  // Update form state with value
  dispatch(actions.changePayout(id, new FormValue(id, value)));
};

const validatePayout = id => (dispatch) => {
  dispatch(validateItem(id));
  dispatch(validateForm());
};

const changePayoutDate = date => (dispatch, getState) => {
  const { payouts } = getState().payouts;
  const selectId = payout => payout.id;
  const dispatchUpdateServer = compose(dispatch, updateServer, selectId);

  dispatch(actions.changePayoutDate(date));
  return Promise.all(payouts.filter(p => !p.isProposal).map(dispatchUpdateServer))
    .then(() => dispatch(canSendToPostControlCheck()));
};

const savePayout = () => (dispatch, getState) => {
  const { type } = getState().payouts.form.data;
  const { payoutDate } = getState().payouts;

  dispatch(validateForm());
  Object.values(validatePayoutMap).forEach((entry) => {
    dispatch(validateItem(entry));
  });
  const { valid } = getState().payouts.form;
  if (!valid) return;

  Promise.all([
    dispatch(actions.savePayout()),
    dispatch(updateCustomerPayout()),
    dispatch(updatePayoutAmount()),
    dispatch(actions.hideForm()),
    dispatch(actions.clearForm())])
    .then(() => dispatch(changePayoutDate(payoutDate)))
    .then(() => dispatch(maybeResetCustomerPayout(type.value)))
    .then(() => dispatch(actions.updateViewModel()));
};

const abort = () => (dispatch) => {
  dispatch(actions.clearForm());
  dispatch(actions.hideForm());
};

const deletePayout = id => (dispatch) => {
  dispatch(actions.deletePayout(id));
  dispatch(updateCustomerPayout());
  dispatch(updatePayoutAmount());
  dispatch(deleteFromServer(id))
    .then(() => dispatch(maybeResetCustomerPayout()))
    .then(() => dispatch(canSendToPostControlCheck()))
    .then(() => dispatch(actions.updateViewModel()));
};

const selectBankRecipient = id => (dispatch, getState) => {
  dispatch(actions.selectRecipient(id));
  dispatch(actions.setFormValidity(isEditPayoutBankFormValid(getState().payouts.form.data)));
};

const selectBrokerRecipient = id => (dispatch, getState) => {
  dispatch(actions.selectRecipient(id));
  dispatch(actions.setFormValidity(isEditPayoutBrokerFormValid(getState().payouts.form.data)));
};

const refreshAmountInternal = (contractNumber, accountNumber, amount) => (dispatch, getState) => {
  dispatch(actions.writeErrorMessage(''));
  dispatch(actions.fetchingContractSettlement());
  const errorMessage = 'Noe gikk galt ved uthenting av internt beløp';
  const { getContractSettlementUrl, payoutDate, customerId } = getState().payouts;
  const successHandler = response => dispatch(actions.contractSettlementReceived(response));
  const errorHandler = error => dispatch(actions.getContractSettlementFailed(`\n ${errorMessage}: ${error}`));

  getChanged(getContractSettlementUrl, { customerId, settlementDate: moment(payoutDate).format('YYYY-MM-DD'), loanContractNumber: contractNumber, paymentAccountNumber: accountNumber, loanAmount: amount })
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        dispatch(successHandler(response));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

const toPostControl = () => (dispatch, getState) => {
  dispatch(actions.writeErrorMessage(''));
  const { canSendToPostControl } = getState().payouts;
  if (!canSendToPostControl) return Promise.resolve('Not possible!');
  const errorMessage = 'Noe gikk galt ved sending til etterkontroll';
  dispatch(actions.sendingToPostControl());

  const { sendToPostControlUrl } = getState().payouts;
  const successHandler = (result) => {
    Promise.all([
      dispatch(actions.sendToPostControlSuccess)
    ]).then(() => window.location.replace(result.url));
  };

  const errorHandler = error => dispatch(actions.sendToPostControlFailed(`\n ${errorMessage}: ${error}`));

  return postChanged(sendToPostControlUrl)
    .then((response) => {
      if (response.message) {
        dispatch(errorHandler(response.message));
      } else {
        dispatch(successHandler(response));
      }
    }, (error) => {
      if (responseIsJson(error)) {
        error.json().then((json) => {
          dispatch(errorHandler(json));
        });
      } else {
        error.text().then((txt) => {
          dispatch(errorHandler(txt));
        });
      }
    });
};

const showEmailForm = (payoutId, documentId) => (dispatch, getState) => {
  const { payouts } = getState().payouts;
  let payout = payouts.find(p => p.id === payoutId);

  if (!payout) {
    const { defaultEmailAddress } = getState().emailBox;
    payout = { id: 0, documentId, email: defaultEmailAddress };
  }

  dispatch(eMailFormOperations.prepareEmailForm(payout, documentId)).then(() => dispatch(actions.showEmailForm()));
};

const closeEmailForm = () => (dispatch) => {
  // dispatch(cleanEmailForm());
  dispatch(actions.hideEmailForm());
};

export default {
  initPayouts,
  newPayout,
  editPayout,
  validatePayout,
  savePayout,
  changePayout,
  abort,
  deletePayout,
  selectBankRecipient,
  selectBrokerRecipient,
  changePayoutDate,
  refreshAmountInternal,
  toPostControl,
  showEmailForm,
  closeEmailForm,
  getRecipients
};