/*!
 *
 * Copyright (c) 2021-2024 Diality Inc. - All Rights Reserved.
 * \copyright
 * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
 * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
 *
 * \file    PreTreatmentStack.qml
 * \author  (last)      Behrouz NematiPour
 * \date    (last)      02-Feb-2023
 * \author  (original)  Behrouz NematiPour
 * \date    (original)  21-Jun-2021
 *
 */

// Qt
import QtQuick 2.12

// Project
//  Qml imports
import "qrc:/globals"
import "qrc:/components"
import "qrc:/compounds"
import "qrc:/pages/pretreatment"
import "qrc:/pages/pretreatment/create"

/*!
 * \brief   the pre treatment stack screen
 */
StackItem { id: _root
    stackView.initialItem   :  null

    enum Step {
        Concentrates    ,
        Installation    ,
        SelfTests       ,
        Saline          ,
        Prime           ,
        CreateRx        ,
        Connect
    }

    property var stepNames              : [] // step name parallel list
    property var stepKeys               : [] // step enum parallel list
    property int stackStepIndex         : 0
    readonly property bool isInstall    : stepKeys[_root.stackStepIndex] === PreTreatmentStack.Step.Installation
    readonly property bool isCreateRx   : stepKeys[_root.stackStepIndex] === PreTreatmentStack.Step.CreateRx

    onVisibleChanged: {
        if (visible) {
            rebuildMap()
            _mainMenu.hidden = true
            _headerBar.titleText = qsTr("Setup Treatment")
            _root.stackStepIndex = 0
        }
        else {
            stackView.initialItem = null
            _headerBar.titleText = ""
        }
    }

    // dynamically rebuild map 🗺️ when entering pretreatment.
    // { step key (enum) : step name (string) } -- decided to use 2 parallel list for better indexing
    function rebuildMap() {
        let keys    = [] // parallel key list of step enum
        let values  = [] // parallel step name string list

        if ( ! vSettings.advancedMode ) {
            keys.push(PreTreatmentStack.Step.Concentrates)
            values.push(qsTr("Concentrates"))
        }

        keys.push(PreTreatmentStack.Step.Installation)
        values.push(qsTr("Installation"))

        keys.push(PreTreatmentStack.Step.SelfTests)
        values.push(qsTr("Self-Tests"))

        keys.push(PreTreatmentStack.Step.Saline)
        values.push(qsTr("Saline"))

        keys.push(PreTreatmentStack.Step.Prime)
        values.push(qsTr("Prime"))

        keys.push(PreTreatmentStack.Step.CreateRx)
        values.push(qsTr("Rx"))

        keys.push(PreTreatmentStack.Step.Connect)
        values.push(qsTr("Connect"))

        // 📋 reassign to notify bindings
        stepKeys = keys
        stepNames  = values
    }

    // clear create rx parameters
    function clear(vValue) { if ( ! vValue ) return;  _pretreatmentCreate.clear(vValue) }

    // handle ⏭️ confirm clicked on any pretreatment page
    function confirmClicked() {
        switch ( stepKeys[_root.stackStepIndex] ) {
        case PreTreatmentStack.Step.Concentrates:
            page ( _pretreatmentInstallation )
            break
        case PreTreatmentStack.Step.Installation:
            if ( vSettings.advancedMode )   { vPreTreatmentAdjustmentDisposablesConfirm.doConfirm() }
            else                            { _pretreatmentInstallation.continueClicked()           }
            break
        case PreTreatmentStack.Step.SelfTests:
            page ( _pretreatmentSaline )
            break
        case PreTreatmentStack.Step.Saline:
            page ( _pretreatmentPrime )
            break
        case PreTreatmentStack.Step.Prime:
            if ( _pretreatmentPrime.timeCircleProgressValue === 0 ) { vPreTreatmentAdjustmentDisposablesPrime.doPrime();        }
            page ( _pretreatmentCreate )
            break
        case PreTreatmentStack.Step.CreateRx:
            _pretreatmentCreate.confirmButtonClicked()
            if ( vTreatmentCreate.parametersValidated ) { page ( _pretreatmentConnect ) }
            break
        case PreTreatmentStack.Step.Connect:
            vPreTreatmentAdjustmentStartTreatment.doStart()
            break
        default:
            break
        }
    }

    // handle 🔙 back clicked on any pretreatment page
    function backClicked() {
        switch ( stepKeys[_root.stackStepIndex] ) {
        case PreTreatmentStack.Step.Concentrates:
            vPreTreatmentAdjustmentInitTreatment.doCancel() // request standby
            break
        case PreTreatmentStack.Step.Installation:
            if ( vSettings.advancedMode )   { vPreTreatmentAdjustmentInitTreatment.doCancel()   }
            else                            { _pretreatmentInstallation.backClicked()           }
            break
        default:
            break
        }
    }

    // handle text for the confirm button on any pretreatment page
    function confirmButtonText() {
        switch ( stepKeys[_root.stackStepIndex] ) {
        case PreTreatmentStack.Step.Installation:
            return _pretreatmentInstallation.confirmButtonText()
        case PreTreatmentStack.Step.CreateRx:
            return vTreatmentCreate.parametersValidated
                   ? qsTr("Confirm")
                   : qsTr("Validate")
        case PreTreatmentStack.Step.Connect:
            return qsTr("Start")
        default:
            return qsTr("Next")
        }
    }

    function backEnabled() {
        switch ( stepKeys[_root.stackStepIndex] ) {
        case PreTreatmentStack.Step.Concentrates:
            return true
        case PreTreatmentStack.Step.Installation:
            return _pretreatmentInstallation.backEnabled()
        default:
            return false // majority of pages back is disabled
        }
    }

    function confirmEnabled() {
        switch ( stepKeys[_root.stackStepIndex] ) {
//        case PreTreatmentStack.Step.SelfTests:        // TODO set when implementing self test/ prime
//            return _pretreatmentSelfTests.isComplete
//        case PreTreatmentStack.Step.Prime:
//            return _pretreatmentPrime.isComplete
        case PreTreatmentStack.Step.CreateRx:
            return _pretreatmentCreate.confirmReady()
        default:
            return true
        }
    }

    // Header
    StepNavigationTitleBar { id: _titleBar
        stepIndex       : _root.stackStepIndex
        anchors {
            top         : _root.top
            left        : parent.left
            right       : parent.right
            leftMargin  : Variables.defaultMargin * 2
            rightMargin : anchors.leftMargin
        }
        confirmText.text: confirmButtonText()
        confirmVisible  : true
        confirmEnabled  : _root.confirmEnabled()
        backVisible     : true
        backEnabled     : _root.backEnabled()
        width           : _root.width
        stepNames       : _root.stepNames
        subStepIndex    : isInstall ? _pretreatmentInstallation.subStepIndex + 1 : 0
        subSteps        : {
            let arr =Array(stepNames.length).fill(0)
            if ( ! vSettings.advancedMode ) { arr[stepKeys.indexOf(PreTreatmentStack.Step.Installation)] = PreTreatmentInstallStack.Step.Count }
            return arr
        }

        onBackClicked   : _root.backClicked()
        onConfirmClicked: _root.confirmClicked()
    }

    // Pages
    PreTreatmentBase    { id:   _pretreatmentConcentrates
        instructionBased    : true
        onVisibleChanged    : if (visible) { _root.stackStepIndex = stepKeys.indexOf(PreTreatmentStack.Step.Concentrates); updateModel()    }
    }

    PreTreatmentInstallStack { id: _pretreatmentInstallation
        onVisibleChanged    : if (visible) { _root.stackStepIndex = stepKeys.indexOf(PreTreatmentStack.Step.Installation);  initStack()     }
    }

    PreTreatmentSelfTests{ id:   _pretreatmentSelfTests
        onVisibleChanged    : if (visible) { _root.stackStepIndex = stepKeys.indexOf(PreTreatmentStack.Step.SelfTests);                     }
    }

    PreTreatmentBase    { id:   _pretreatmentSaline
        instructionBased    : true
        onVisibleChanged    : if (visible) { _root.stackStepIndex = stepKeys.indexOf(PreTreatmentStack.Step.Saline);        updateModel()   }
    }

    PreTreatmentPrime    { id:   _pretreatmentPrime
        onVisibleChanged    : if (visible) { _root.stackStepIndex = stepKeys.indexOf(PreTreatmentStack.Step.Prime);                         }
    }

    PreTreatmentCreate  { id:   _pretreatmentCreate
        onVisibleChanged    : if (visible) { _root.stackStepIndex = stepKeys.indexOf(PreTreatmentStack.Step.CreateRx)                       }
    }

    PreTreatmentBase    { id:   _pretreatmentConnect
        instructionBased    : true
        onVisibleChanged    : if (visible) { _root.stackStepIndex = stepKeys.indexOf(PreTreatmentStack.Step.Connect);       updateModel()   }
    }

    // Slots
    Connections { target: vTDOpMode
        function onPreTreatmentChanged( vValue ) {  if ( vSettings.advancedMode )   { page ( _pretreatmentInstallation      , vValue    )}
                                                    else                            { page ( _pretreatmentConcentrates      , vValue    )}
        }
    }

    // Installation
    Connections { target: _pretreatmentInstallation
        function onGoToNextStep ()      { page ( _pretreatmentSelfTests     )}
        function onGoToPreviousStep ()  { page ( _pretreatmentConcentrates  )}
    }

    // priming
    Connections { target: vPreTreatmentAdjustmentDisposablesPrime
        function onAdjustmentTriggered                              ( vValue ) {
            if ( vPreTreatmentAdjustmentDisposablesPrime.adjustment_Accepted ) {
                _pretreatmentPrime.reasonText = ""
            } else {
                _pretreatmentPrime.reasonText = vPreTreatmentAdjustmentDisposablesPrime.text()
            }
        }
    }

    // TODO - keep for now Ultrafiltration is beingn moved into Create Rx
//    Connections { target: vPreTreatmentAdjustmentUltrafiltrationInit
//        function onAdjustmentTriggered          ( vValue ) {
//            // the maximum ultrafiltration volume has to be set/revert regardless
//            vTreatmentUltrafiltration.maximum   = vPreTreatmentAdjustmentUltrafiltrationInit.volume

//            // but only if it has been accepted it will navigate
//            if ( vPreTreatmentAdjustmentUltrafiltrationInit.adjustment_Accepted ) {
//            }
//            else {
//                _pretreatmentDialysateUf.reasonText = vPreTreatmentAdjustmentUltrafiltrationInit.text()
//            }
//        }
//    }

    // start treatment
    Connections { target: vPreTreatmentAdjustmentStartTreatment
        function onAdjustmentTriggered          ( vValue ) {
            if ( vPreTreatmentAdjustmentStartTreatment.adjustment_Accepted ) {
                _pretreatmentConnect.reasonText = ""
            } else {
                _pretreatmentConnect.reasonText = vPreTreatmentAdjustmentStartTreatment.text()
            }
        }
    }

    // TODO - update in future story. Keep for now
 //    Connections { target: vPreTreatmentStates
 //        function onWaterSampleChanged           ( vValue ) { page( _preTreatmentWaterSampleStack , vValue )}
 //        function onSelfTestConsumablesChanged   ( vValue ) { page( _preTreatmentConsumablesStack , vValue )}
 //        function onSelfTestNoCartridgeChanged   ( vValue ) { page( _preTreatmentDisposablesStack , vValue )}
 //        function onInstallationChanged          ( vValue ) { page( _preTreatmentDisposablesStack , vValue )} // DEBUG: Experimental : console.debug("vinstallation       "
 //        function onSelfTestDryChanged           ( vValue ) { page( _pretreatmentPrimeStack       , vValue )}
 //        function onPrimeChanged                 ( vValue ) { page( _pretreatmentPrimeStack       , vValue )} // DEBUG: Experimental : console.debug("vprime              "
 //        function onRecirculateChanged           ( vValue ) { page( _pretreatmentPrimeStack       , vValue )} // DEBUG: Experimental : console.debug("vrecirculate        "
 //        function onPatientConnectionChanged     ( vValue ) { page( _pretreatmentConnectionStack  , vValue )}
 //    }
}