package tech.ivoice.apps.scenarion.bizon;


import com.google.common.collect.ImmutableList;
import tech.ivoice.platform.extension.sdk.components.request_option.EnumRequestOptionComponent;
import tech.ivoice.platform.extension.sdk.components.request_option.common.YesNo;
import tech.ivoice.platform.extension.sdk.fsm_support.MessageProvider;
import tech.ivoice.platform.extension.sdk.fsm_support.Platform;
import tech.ivoice.platform.fsm.FsmContext;
import tech.ivoice.platform.fsm.OutState;
import tech.ivoice.platform.fsm.State;
import tech.ivoice.platform.sdk.messages.SolutionMessage;
import tech.ivoice.platform.sdk.messages.common.PlaySource;
import tech.ivoice.platform.sdk.messages.session.PlayCollectSpeech;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

import static tech.ivoice.platform.extension.sdk.fsm_support.Tools.submitLink;
import static tech.ivoice.platform.extension.sdk.fsm_support.Tools.link;

public class BizonScenarioMainComponent {
    public static final String DEFAULT_LANG = "ru-RU";
    private Logger log = Logger.getLogger(BizonScenarioMainComponent.class.getName());
    private Platform platform;
    private Audios plays;

    private FsmContext<BizonScenarioMainComponent> context = FsmContext.of(this, "bizon_scenario");
    public OutState<BizonScenarioMainComponent> initScenario = context.outState("bizon_scenario_init");

    private OutState<BizonScenarioMainComponent> done = context.outState("done", false);
    private OutState<BizonScenarioMainComponent> fail = context.outState("fail", false);

    private EnumRequestOptionComponent<YesNo> requestYesNoFirst;
    private   Map<String, Object> solutionParameters;

    private final static String operatorPhone = "Ввести телефон";

    private Parameters parameters;
    private enum ParametersDTO {
        DATE
    }

    private class Parameters{
        private Map<String,String> parameters;
         solutionParameters = (Map<String, Object>) message

        public Parameters(Map<String, String> parameters) {
            this.parameters = parameters;
        }


        public String getDate(){
            return parameters.get(ParametersDTO.DATE.name()).toLowerCase();
        }

    }

    public BizonScenarioMainComponent(Platform platform){
        this.platform = platform;
        plays = new Audios();
        link(initScenario, firstQuestion);
    }
    private State<BizonScenarioMainComponent> firstQuestion = context.state("firstQuestion")
            .onEnter(( (message, currentState, states, actions) -> {
;
                solutionParameters.forEach((k, v) -> {
                    System.out.println(k + " " + v);
                });

                Map<String, String> param = new HashMap<>();

                solutionParameters.forEach((k, v) -> {
                    if ((v instanceof String)) {
                        param.put(k, (String) v);
                    }
                });

                requestYesNoFirst  = initializeRequestYesNoFirst();
                parameters = new Parameters(param);

                submitLink(requestYesNoFirst.option(YesNo.YES),states.playIfYes,platform,"интерес", "да");
                submitLink(requestYesNoFirst.option(YesNo.NO),states.playIfNo,platform,"интерес", "нет");
                submitLink(requestYesNoFirst.fail, states.playRedirect, platform, "интерес", "молчание");
                submitLink(requestYesNoFirst.unknown, states.playRedirect, platform, "интерес", "другой ответ");




                return actions.redirect(requestYesNoFirst.start);

            })).transitions((BizonScenarioMainComponent comp) -> ImmutableList.of(comp.requestYesNoFirst.start)).
                    build();

    private State<BizonScenarioMainComponent> playIfYes = context.state("yesAnswer")
            .onEnter((message, state, states) -> {
                platform.accept((SolutionMessage) plays.playSourceIfYes());
                platform.accept(plays.redirectOperator(operatorPhone));
            })
            .build();

    private State<BizonScenarioMainComponent> playIfNo = context.state("noAnswer")
            .onEnter((message, state, states) -> {
                platform.accept((SolutionMessage) plays.playSourceIfNo());
                platform.accept(plays.hangup());
            })
            .build();
    private State<BizonScenarioMainComponent> playRedirect= context.state("redirectAnswer")
            .onEnter((message, state, states) -> {
                platform.accept((SolutionMessage) plays.playSourceRedirect());
                platform.accept(plays.redirectOperator(operatorPhone));
            })
            .build();


    private EnumRequestOptionComponent<YesNo> initializeRequestYesNoFirst() {
        List<MessageProvider<PlayCollectSpeech>> retryAsks = new LinkedList<>();
        retryAsks.add(() -> plays.playCollectRepeatFirstQuestion());
        return new EnumRequestOptionComponent<>(platform, () -> plays.playColleсtFirstQuestion(
                parameters.getDate()),
                retryAsks,
                YesNo.class,
                DEFAULT_LANG);
    }


}