package au.com.ds.eft;

import au.com.ds.ef.*;
import au.com.ds.ef.call.*;

import static au.com.ds.ef.FlowBuilder.*;
import static au.com.ds.eft.Main1.Events.*;
import static au.com.ds.eft.Main1.States.*;

/**
 * User: andrey
 * Date: 23/09/13
 * Time: 10:27 PM
 */
public class Main1 {
    private static class FlowContext extends StatefulContext {
        private int balance = 1000;
        private String pin;
        private int invalidPinCounter;
        private int withdrawAmt;
    }

    public enum States implements StateEnum {
        SHOWING_WELCOME,
        WAITING_FOR_PIN,
        CHECKING_PIN,
        RETURNING_CARD,
        SHOWING_MAIN_MENU,
        SHOWING_PIN_INVALID,
        SHOWING_CARD_LOCKED,
        SHOWING_BALANCE,
        SHOWING_WITHDRAW_MENU,
        SHOWING_TAKE_CASH,
        TERMINATED
    }

    public enum Events implements EventEnum {
        cardPresent,
        cardExtracted,
        pinProvided,
        pinValid,
        pinInvalid,
        tryAgain,
        noMoreTries,
        cancel,
        confirm,
        menuShowBalance,
        menuWithdrawCash,
        menuExit,
        switchOff,
        cashExtracted
    }

    private IoController ioController;

    private EasyFlow<FlowContext> easyFlow;

    public static void main(String[] args) throws InterruptedException {
        Main1 m = new Main1();

        m.initFlow();
        m.bindFlow();
        m.startFlow();

        Thread.sleep(Long.MAX_VALUE);
    }

    private void initFlow() {
        ioController = new IoController();
        ioController.init();

        easyFlow =

            from(SHOWING_WELCOME).transit(
                on(cardPresent).to(WAITING_FOR_PIN).transit(
                    on(pinProvided).to(CHECKING_PIN).transit(
                        on(pinValid).to(SHOWING_MAIN_MENU).transit(
                            on(menuShowBalance).to(SHOWING_BALANCE).transit(
                                on(cancel).to(SHOWING_MAIN_MENU)
                            ),
                            on(menuWithdrawCash).to(SHOWING_WITHDRAW_MENU).transit(
                                on(cancel).to(SHOWING_MAIN_MENU),
                                on(confirm).to(SHOWING_TAKE_CASH).transit(
                                    on(cashExtracted).to(SHOWING_MAIN_MENU)
                                )
                            ),
                            on(menuExit).to(RETURNING_CARD)
                        ),
                        on(pinInvalid).to(SHOWING_PIN_INVALID).transit(
                            on(tryAgain).to(WAITING_FOR_PIN),
                            on(noMoreTries).to(SHOWING_CARD_LOCKED).transit(
                                on(confirm).to(SHOWING_WELCOME)
                            ),
                            on(cancel).to(RETURNING_CARD)
                        )
                    ),
                    on(cancel).to(RETURNING_CARD).transit(
                        on(cardExtracted).to(SHOWING_WELCOME)
                    )
                ),
                on(switchOff).finish(TERMINATED)
            );
    }

    private void bindFlow() {
        easyFlow

            .whenEnter(SHOWING_WELCOME, new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                ioController.println("\n\n*** Welcome ***\n---------------");
                showOption("Select your option and press [Enter]...\n 1 Insert card\n 2 Terminate ATM", new IoController.InputEventHandler() {
                    @Override
                    public void onInputEvent(String s) {
                        if (s.equals("1")) {
                            context.trigger(cardPresent);
                        } else {
                            context.trigger(switchOff);
                        }
                    }
                });
                context.invalidPinCounter = 0;
            }
        })

        .whenEnter(WAITING_FOR_PIN, (new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                ioController.println("\n\n*** Waiting for PIN ***\n---------------");
                showOption("Please enter your PIN and press [Enter] or just press [Enter] to cancel (current PIN is 1234)...", new IoController.InputEventHandler() {
                    @Override
                    public void onInputEvent(String s) {
                        if (s.length() == 4) {
                            context.pin = s;
                            context.trigger(pinProvided);
                        } else {
                            // no pin is provided - cancel
                            context.trigger(cancel);
                        }
                    }
                });
            }
        }))

        .whenEnter(CHECKING_PIN, new ContextHandler<FlowContext>() {
            @Override
            public void call(FlowContext context) throws Exception {
                if (context.pin.equals("1234")) {
                    context.trigger(pinValid);
                } else {
                    context.invalidPinCounter++;
                    context.trigger(pinInvalid);
                }
            }
        })

        .whenEnter(SHOWING_MAIN_MENU, new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                ioController.println("\n\n*** Main Menu ***\n---------------");
                showOption("Select your option and press [Enter]...\n1 See my balance\n2 Get cash\n3 Exit", new IoController.InputEventHandler() {
                    @Override
                    public void onInputEvent(String s) {
                        if (s.equals("1")) {
                            context.trigger(menuShowBalance);
                        } else if (s.equals("2")) {
                            context.trigger(menuWithdrawCash);
                        } else if (s.equals("3")) {
                            context.trigger(menuExit);
                        }
                    }
                });
            }
        })

        .whenEnter(SHOWING_BALANCE, new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                ioController.println("\n\n*** Showing Balance ***\n---------------");
                ioController.println("You currently have $" + context.balance + " on your account");
                showOption("Press [Enter] to continue...", new IoController.InputEventHandler() {
                    @Override
                    public void onInputEvent(String s) {
                        context.trigger(cancel);
                    }
                });
            }
        })

        .whenEnter(SHOWING_WITHDRAW_MENU, new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                ioController.println("\n\n*** Withdraw Cash ***\n---------------");
                ioController.println("How much cash do you want to withdraw?\n" +
                    "Choose your option and press [Enter] to confirm...");
                showOption("\n1 for $50\n2 for $100\n3 for $200\n4 to cancel", new IoController.InputEventHandler() {
                    @Override
                    public void onInputEvent(String s) {
                        int amt = 0;

                        if (s.equals("1")) {
                            amt = 50;
                        } else if (s.equals("2")) {
                            amt = 100;
                        } else if (s.equals("3")) {
                            amt = 200;
                        }

                        if (amt == 0) {
                            context.trigger(cancel);
                        } else {
                            context.withdrawAmt = amt;
                            context.trigger(confirm);
                        }
                    }
                });
            }
        })

        .whenEnter(SHOWING_TAKE_CASH, new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                ioController.println("\n\n*** Take your cash ***\n---------------");
                ioController.println("Please, take your cash");
                showOption("Take my $" + context.withdrawAmt + " press [Enter]...", new IoController.InputEventHandler() {
                    @Override
                    public void onInputEvent(String s) {
                        context.balance -= context.withdrawAmt;
                        context.trigger(cashExtracted);
                    }
                });
            }
        })

        .whenEnter(SHOWING_PIN_INVALID, new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                boolean canTryAgain = context.invalidPinCounter < 3;

                ioController.println("\n\n*** Invalid PIN ***\n---------------");
                ioController.println("You entered invalid PIN.\n(" + (3 - context.invalidPinCounter) + " attempts left)");
                if (canTryAgain) {
                    showOption("Choose your option and press [Enter]...\n1 Try again\n2 Cancel", new IoController.InputEventHandler() {
                        @Override
                        public void onInputEvent(String s) {
                            if (s.equals("1")) {
                                context.trigger(tryAgain);
                            } else {
                                context.trigger(cancel);
                            }
                        }
                    });
                } else {
                    showOption("Press [Enter] to continue...", new IoController.InputEventHandler() {
                        @Override
                        public void onInputEvent(String s) {
                            context.trigger(noMoreTries);
                        }
                    });
                }
            }
        })

        .whenEnter(SHOWING_CARD_LOCKED, new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                ioController.println("\n\n*** Your Card has been locked ***\n---------------");
                ioController.println("You have entered invalid PIN 3 times so I swallowed your card.\n" +
                    "Mmm... Yummy ;)");
                showOption("Press [Enter] to continue...", new IoController.InputEventHandler() {
                    @Override
                    public void onInputEvent(String s) {
                        context.trigger(confirm);
                    }
                });
            }
        })

        .whenEnter(RETURNING_CARD, new ContextHandler<FlowContext>() {
            @Override
            public void call(final FlowContext context) throws Exception {
                ioController.println("\n\n*** Returning Card ***\n---------------");
                ioController.println("Thanks for using our ATM");
                showOption("Please take your card - press [Enter]...", new IoController.InputEventHandler() {
                    @Override
                    public void onInputEvent(String s) {
                        context.trigger(cardExtracted);
                    }
                });
            }
        })

        .whenEnter(TERMINATED, new ContextHandler<FlowContext>() {
            @Override
            public void call(FlowContext flowContext) throws Exception {
                System.exit(0);
            }
        });
    }

    private void startFlow() {
        easyFlow.start(new FlowContext());
    }

    private void showOption(String title, final IoController.InputEventHandler handler) {
        ioController.println(title);
        ioController.setEventHandler(handler);
    }
}