// @flow
export type Account = {
    id: number,
    username: string,
    email: string,
    token: string,
    refreshToken: ?string
};

export type State = {
    active: ?number,
    available: Array<Account>
};

export type AddAction = { type: 'accounts:add', payload: Account };
export type RemoveAction = { type: 'accounts:remove', payload: Account };
export type ActivateAction = { type: 'accounts:activate', payload: Account };
export type UpdateTokenAction = {
    type: 'accounts:updateToken',
    payload: string
};
export type ResetAction = { type: 'accounts:reset' };

type Action =
    | AddAction
    | RemoveAction
    | ActivateAction
    | UpdateTokenAction
    | ResetAction;

export function getActiveAccount(state: { accounts: State }): ?Account {
    const accountId = state.accounts.active;

    return state.accounts.available.find((account) => account.id === accountId);
}

export function getAvailableAccounts(state: {
    accounts: State
}): Array<Account> {
    return state.accounts.available;
}

export default function accounts(
    state: State = {
        active: null,
        available: []
    },
    action: Action
): State {
    switch (action.type) {
        case 'accounts:add': {
            if (
                !action.payload
                || !action.payload.id
                || !action.payload.token
            ) {
                throw new Error(
                    'Invalid or empty payload passed for accounts.add'
                );
            }
            const { payload } = action;

            state.available = state.available
                .filter((account) => account.id !== payload.id)
                .concat(payload);

            state.available.sort((account1, account2) => {
                if (account1.username === account2.username) {
                    return 0;
                }

                return account1.username > account2.username ? 1 : -1;
            });

            return state;
        }

        case 'accounts:activate': {
            if (
                !action.payload
                || !action.payload.id
                || !action.payload.token
            ) {
                throw new Error(
                    'Invalid or empty payload passed for accounts.add'
                );
            }

            const { payload } = action;

            return {
                available: state.available.map((account) => {
                    if (account.id === payload.id) {
                        return { ...payload };
                    }

                    return { ...account };
                }),
                active: payload.id
            };
        }

        case 'accounts:reset':
            return {
                active: null,
                available: []
            };

        case 'accounts:remove': {
            if (!action.payload || !action.payload.id) {
                throw new Error(
                    'Invalid or empty payload passed for accounts.remove'
                );
            }

            const { payload } = action;

            return {
                ...state,
                available: state.available.filter(
                    (account) => account.id !== payload.id
                )
            };
        }

        case 'accounts:updateToken': {
            if (typeof action.payload !== 'string') {
                throw new Error('payload must be a jwt token');
            }

            const { payload } = action;

            return {
                ...state,
                available: state.available.map((account) => {
                    if (account.id === state.active) {
                        return {
                            ...account,
                            token: payload
                        };
                    }

                    return { ...account };
                })
            };
        }

        default:
            (action: empty);
            return state;
    }
}