package com.ppretail.adyen.business;

import com.adyen.jni.clib.*;
import com.ppretail.adyen.lib.ResultHandler;
import com.ppretail.adyen.lib.ped.MerchantPed;
import com.ppretail.adyen.lib.ped.PedCallbackHandler;
import com.ppretail.adyen.lib.ped.PedCallbackResultHandler;
import com.ppretail.adyen.lib.pos.MerchantPos;
import com.ppretail.adyen.lib.pos.PosCallbackHandler;
import com.ppretail.adyen.lib.pos.PosCallbackResultHandler;
import com.ppretail.adyen.lib.pos.PosHandler;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;

import java.util.Collections;
import java.util.List;

@Slf4j
@ToString
class PointOfSale {

    private final MerchantPos pos;
    private final MerchantPed ped;
    private final Environment environment;

    private PosHandler posHandler = new PosHandler();
    private PosCallbackResultHandler posCallbackResultHandler = new PosCallbackResultHandler();
    private PedCallbackResultHandler pedCallbackResultHandler = new PedCallbackResultHandler();
    private String merchant;
    private String user;
    private String password;
    private String posId;

    private Waiter initLibraryWaiter = new InitLibraryWaiter();
    private Waiter pedRegistrationWaiter = new PedRegistrationWaiter();
    private Waiter finalStateWaiter = new FinalStateWaiter();

    PointOfSale(String posId, String terminalIp, String terminalPedName, String environment, String merchant, String user, String password) throws Exception {
        this.posId = posId;
        this.merchant = merchant;
        this.user = user;
        this.password = password;
        this.pos = new MerchantPos();
        this.ped = new MerchantPed(terminalIp, terminalPedName);
        this.environment = Environment.getEnvironment(environment);

        addPosCallBackHandler();
        addPedCallbackHandler();
        initLibrary();
        registerPed();
    }

    Tender createPayment(String merchantAccount, String merchantReference, String currency, long amount) throws TransactionException {
        log.info("Starting tender creation for the merchant reference: {}" , merchantReference);
        Tender basicTender = buildBasicTender(merchantAccount, merchantReference, currency, amount);
        log.debug("Basic tender: {}" , basicTender);
        LibraryResult result = ped.createTender(basicTender, new AdditionalData());
        ResultHandler resultHandler = new ResultHandler();
        resultHandler.checkResult(ped, result);
        finalStateWaiter.run();
        resultHandler.checkResult(ped, ped.getResultCreateTender());
        Tender resultTenderFinal = ped.getResultTenderFinal();
        log.info("The tender final result for merchant reference: {} is : {}" , merchantReference, resultTenderFinal);
        return resultTenderFinal;
    }

    private Tender buildBasicTender(String merchantAccount, String merchantReference, String currency, long amount) throws TransactionException {
        List<Transaction.TenderOption> tenderOptions = Collections.singletonList(Transaction.TenderOption.ReceiptHandler);
        Tender.TenderOption[] tenderOptionsArray = tenderOptions.toArray(new Tender.TenderOption[tenderOptions.size()]);
        Tender.TenderType tenderType = Tender.TenderType.GOODS_SERVICES;

        return new Tender(
                merchantAccount,
                merchantReference,
                tenderType,
                currency,
                amount,
                tenderOptionsArray);
    }

    private void addPedCallbackHandler() {
        this.ped.addPedCallbackHandler(new PedCallbackHandler() {
            @Override
            public void pedStateChangeCallbackHandler() {
                log.info("ResultPedStateChange: " + ped.getResultPedStateChange().getPedState().getNameInClib());
                if (pedCallbackResultHandler.handlePedStateChangeResult(ped))
                    log.debug("Ped: " + ped.getPedName() + " is ready");
            }

            @Override
            public void showScreenCallbackHandler() {
                pedCallbackResultHandler.handleShowScreenResult();
            }

            @Override
            public void createTenderCallbackHandler() {

                if (pedCallbackResultHandler.handleCreateTenderResult(ped)) {
                    log.debug("tenderCreated on the ped: " + ped);
                } else {
                    log.error("tenderCreateError on the ped: " + ped);
                    refreshPed();
                }
            }

            private void refreshPed() {
                ped.refreshPEDstate(5);
            }

            @Override
            public void progressCallbackHandler() {
                if (pedCallbackResultHandler.handleProgressResult(ped)) {
                    Transaction.TenderState tenderState = ped.getResultTenderProgress().getTenderState();
                    log.debug("progressCallbackHandler - tenderState on ped: {} is: {}", ped, tenderState);
                } else {
                    log.error("progressCallbackHandler error  on the ped: " + ped);
                }
            }

            @Override
            public void additionalDataCallbackHandler() {
                if (pedCallbackResultHandler.handleAdditionalDataResult(ped)) {
                    Tender tender = ped.getResultTenderAdditionalData();
                    log.debug("additionalDataCallbackHandler on the ped: {} with the tender: {}", ped, tender);
                } else {
                    log.error("additionalDataCallbackHandler error on the ped: {} ", ped);
                }
            }

            @Override
            public void tenderDccCallbackHandler() {
                pedCallbackResultHandler.handleTenderDccResult(ped);
            }

            @Override
            public void tenderPrintReceiptCallbackHandler() {
            }

            @Override
            public void tenderCheckSignatureCallbackHandler() {
                if (pedCallbackResultHandler.handleTenderCheckSignatureResult(ped)) {
                    Tender tender = ped.getResultTenderCheckSignature();
                    log.debug("tenderCheckSignatureCallbackHandler on the ped: {} enableCheckSignatureForm: {}", ped,
                            tender.getAdditionalData().get("signature.data"));
                }
            }

            @Override
            public void finalCallbackHandler() {
                if (pedCallbackResultHandler.handleFinalResult(ped)) {
                    log.debug("finalCallbackHandler on ped: {}", ped);
                    finalStateWaiter.stop();
                } else {
                    log.error("transactionError");
                    refreshPed();
                }
            }

            @Override
            public void pedExceptionCallbackHandler() {
                if (!pedCallbackResultHandler.handlePedExceptionResult(ped)) {
                    log.error("Ped exception operation has returned null result with ped: {}", ped);
                } else {
                    log.error("Ped exception with ped: {}. The error message is: {}", ped, ped.getResultPedException().getAdyenResult().getErrorMessage());
                }
            }

            @Override
            public void txStoreQueryCallbackHandler() {
            }
        });
    }

    private void initLibrary() throws Exception {
        log.info("starting initLibrary");
        if (!posHandler.initLibrary(pos, buildInitLibraryRequest())){
            String initLibraryErrorMessage = "initLibrary error with posId: " + this.posId;
            log.error(initLibraryErrorMessage);
            throw new InitLibraryException(initLibraryErrorMessage);
        }
        initLibraryWaiter.run();
    }

    class InitLibraryException extends Exception {
        InitLibraryException(String message) {
            super(message);
        }
    }

    private void registerPed() throws Exception {
        String pedName = this.ped.getPedName();
        log.info("starting registration for ped: {}", pedName);
        if (!posHandler.registerPed(this.pos, this.ped)){
            log.error("Ped registration with ped: {} and pos: {}", pedName, pos);
            throw new PedRegistrationException("Ped registration error");
        }
        pedRegistrationWaiter.run();

    }

    class PedRegistrationException extends Exception {
        PedRegistrationException(String message) {
            super(message);
        }
    }

    private InitLibraryRequest buildInitLibraryRequest() {
        return new InitLibraryRequest.InitLibraryRequestBuilder(
                this.environment, this.posId, null, new LogConfig(LogLevel.DEBUG)).build();
    }

    private void addPosCallBackHandler() {
        pos.addCallbackHandler(new PosCallbackHandler() {
            @Override
            public void initLibraryCallbackHandler() {
                if (posCallbackResultHandler.handleInitLibraryResult(pos))
                    registerPos();
                else {
                    log.error("initLibError");
                }
            }

            private void registerPos() {
                log.info("Starting pos registration for posId: " + posId);
                if (!posHandler.registerPos(pos, buildRegisterPosRequest(posId))) {
                    log.error("Pos registration error for posId: " + posId);
                }
            }

            @Override
            public void registerPosCallbackHandler() {
                if (posCallbackResultHandler.handleRegisterPosResult(pos)) {
                    log.info("Pos registration finished for posId: " + posId);
                    initLibraryWaiter.stop();
                } else {
                    log.error("Pos registration finished with error for posId: " + posId);
                }
            }

            @Override
            public void registerPedCallbackHandler() {
                if (posCallbackResultHandler.handleRegisterPedResult(pos, ped)) {
                    log.info("Ped registration finished for {} on pos {}", ped, posId);
                    pedRegistrationWaiter.stop();
                } else {
                    log.error("Ped registration finished with error");
                }
            }

            @Override
            public void cancelOrRefundAtPspCallbackHandler() {
                if (posCallbackResultHandler.handleCancelOrRefundAtPspResult(pos)) {
                    log.info("Ped cancelOrRefund finished");
                } else {
                    log.error("Ped cancelOrRefund finished with error");
                }
            }

            @Override
            public void exitLibraryCallbackHandler() {
                posCallbackResultHandler.handleExitLibraryResult(pos);
            }

            @Override
            public void exceptionCallbackHandler() {
                posCallbackResultHandler.handleExceptionResult(pos);
            }
        });
    }

    private RegisterPosRequest buildRegisterPosRequest(String posId) {
        return new RegisterPosRequest(merchant, user, password, posId);
    }

    private class InitLibraryWaiter extends Waiter {
    }

    private class PedRegistrationWaiter extends Waiter {
    }

    private class FinalStateWaiter extends Waiter {
    }
}