/* Copyright 2023 Dual Tachyon
 * https://github.com/DualTachyon
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *     Unless required by applicable law or agreed to in writing, software
 *     distributed under the License is distributed on an "AS IS" BASIS,
 *     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *     See the License for the specific language governing permissions and
 *     limitations under the License.
 */
#include "assert.h"
#ifdef ENABLE_FLASHLIGHT
#include "app/flashlight.h"
#endif
#include <assert.h>
#include <stdint.h>
#include <string.h>
#include "mdc1200.h"
#include "app/action.h"
#ifdef ENABLE_AIRCOPY
#include "app/aircopy.h"
#endif
#include "app/app.h"
#include "app/chFrScanner.h"
#include "app/dtmf.h"
#include "driver/uart.h"
#ifdef ENABLE_FMRADIO
#include "app/fm.h"
#endif
#include "app/generic.h"
#include "app/main.h"
#include "app/menu.h"
#include "app/scanner.h"
#ifdef ENABLE_UART
#include "app/uart.h"
#endif
#include "ARMCM0.h"
#include "audio.h"
#include "board.h"
#include "bsp/dp32g030/gpio.h"
#include "driver/backlight.h"
#ifdef ENABLE_FMRADIO
#include "driver/bk1080.h"
#endif
#include "driver/bk4819.h"
#include "driver/gpio.h"
#include "driver/keyboard.h"
#include "driver/st7565.h"
#include "driver/system.h"
#include "am_fix.h"
#include "dtmf.h"
//#include "external/printf/printf.h"
#include "frequencies.h"
#include "functions.h"
#include "helper/battery.h"
#include "misc.h"
#include "radio.h"
#include "settings.h"
#if defined(ENABLE_OVERLAY)
#include "sram-overlay.h"
#endif
#include "ui/battery.h"
#include "ui/inputbox.h"
#include "ui/main.h"
#include "ui/menu.h"
#include "ui/status.h"
#include "ui/ui.h"

static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld);
void (*ProcessKeysFunctions[])(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld) = {
        [DISPLAY_MAIN] = &MAIN_ProcessKeys,
        [DISPLAY_MENU] = &MENU_ProcessKeys,
        [DISPLAY_SCANNER] = &SCANNER_ProcessKeys,

#ifdef ENABLE_FMRADIO
        [DISPLAY_FM] = &FM_ProcessKeys,
#endif

#ifdef ENABLE_AIRCOPY
        [DISPLAY_AIRCOPY] = &AIRCOPY_ProcessKeys,
#endif
};

static_assert(ARRAY_SIZE(ProcessKeysFunctions) == DISPLAY_N_ELEM);
static void CheckForIncoming(void)
{
    if (!g_SquelchLost)
        return;          // squelch is closed

    // squelch is open

    if (gScanStateDir == SCAN_OFF)
    {	// not RF scanning
        if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF)
        {	// dual watch is disabled

#ifdef ENABLE_NOAA
            if (gIsNoaaMode)
				{
					gNOAA_Countdown_10ms = NOAA_countdown_3_10ms;
					gScheduleNOAA        = false;
				}
#endif

            if (gCurrentFunction != FUNCTION_INCOMING)
            {
                FUNCTION_Select(FUNCTION_INCOMING);
                //gUpdateDisplay = true;


            }

            return;
        }

        // dual watch is enabled and we're RX'ing a signal

        if (gRxReceptionMode != RX_MODE_NONE)
        {
            if (gCurrentFunction != FUNCTION_INCOMING)
            {
                FUNCTION_Select(FUNCTION_INCOMING);
                //gUpdateDisplay = true;


            }
            return;
        }

        gDualWatchCountdown_10ms = dual_watch_count_after_rx_10ms;
        gScheduleDualWatch       = false;

        // let the user see DW is not active
        gDualWatchActive = false;
        gUpdateStatus    = true;
    }
    else
    {	// RF scanning
        if (gRxReceptionMode != RX_MODE_NONE)
        {
            if (gCurrentFunction != FUNCTION_INCOMING)
            {
                FUNCTION_Select(FUNCTION_INCOMING);
                //gUpdateDisplay = true;


            }
            return;
        }

        gScanPauseDelayIn_10ms = scan_pause_delay_in_3_10ms;
        gScheduleScanListen    = false;
    }

    gRxReceptionMode = RX_MODE_DETECTED;

    if (gCurrentFunction != FUNCTION_INCOMING)
    {
        FUNCTION_Select(FUNCTION_INCOMING);
        //gUpdateDisplay = true;


    }
}

static void HandleIncoming(void)
{


    if (!g_SquelchLost) {	// squelch is closed
#ifdef ENABLE_DTMF_CALLING
        if (gDTMF_RX_index > 0)
			DTMF_clear_RX();
#endif
        if (gCurrentFunction != FUNCTION_FOREGROUND) {
            FUNCTION_Select(FUNCTION_FOREGROUND);
            gUpdateDisplay = true;
        }
        return;
    }

    bool bFlag = (gScanStateDir == SCAN_OFF && gCurrentCodeType == CODE_TYPE_OFF);
#ifdef ENABLE_NOAA
    if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE) && gNOAACountdown_10ms > 0) {
		gNOAACountdown_10ms = 0;
		bFlag               = true;
	}
#endif

    if (g_CTCSS_Lost && gCurrentCodeType == CODE_TYPE_CONTINUOUS_TONE) {
        bFlag       = true;
        gFoundCTCSS = false;
    }

    if (g_CDCSS_Lost && gCDCSSCodeType == CDCSS_POSITIVE_CODE
        && (gCurrentCodeType == CODE_TYPE_DIGITAL || gCurrentCodeType == CODE_TYPE_REVERSE_DIGITAL))
    {        gFoundCDCSS = false;
    }
    else if (!bFlag)
        return;

#ifdef ENABLE_DTMF_CALLING
    if (gScanStateDir == SCAN_OFF && (gRxVfo->DTMF_DECODING_ENABLE || gSetting_KILLED)) {

		// DTMF DCD is enabled
		DTMF_HandleRequest();
		if (gDTMF_CallState == DTMF_CALL_STATE_NONE) {
			if (gRxReceptionMode != RX_MODE_DETECTED) {
				return;
			}
			gDualWatchCountdown_10ms = dual_watch_count_after_1_10ms;
			gScheduleDualWatch       = false;

			gRxReceptionMode = RX_MODE_LISTENING;

			// let the user see DW is not active
			gDualWatchActive = false;
			gUpdateStatus    = true;

			gUpdateDisplay = true;
			return;
		}
	}
#endif

    APP_StartListening(gMonitor ? FUNCTION_MONITOR : FUNCTION_RECEIVE);
}

static void HandleReceive(void)
{
#define END_OF_RX_MODE_SKIP 0
#define END_OF_RX_MODE_END  1
#define END_OF_RX_MODE_TTE  2

    uint8_t Mode = END_OF_RX_MODE_SKIP;

    if (gFlagTailNoteEliminationComplete)
    {
        Mode = END_OF_RX_MODE_END;
        goto Skip;
    }

    if (gScanStateDir != SCAN_OFF && IS_FREQ_CHANNEL(gNextMrChannel))
    { // we are scanning in the frequency mode
        if (g_SquelchLost)
            return;

        Mode = END_OF_RX_MODE_END;
        goto Skip;
    }

    switch (gCurrentCodeType)
    {
        default:
        case CODE_TYPE_OFF:
            break;

        case CODE_TYPE_CONTINUOUS_TONE:
            if (gFoundCTCSS && gFoundCTCSSCountdown_10ms == 0)
            {
                gFoundCTCSS = false;
                gFoundCDCSS = false;
                Mode        = END_OF_RX_MODE_END;
                goto Skip;
            }
            break;

        case CODE_TYPE_DIGITAL:
        case CODE_TYPE_REVERSE_DIGITAL:
            if (gFoundCDCSS && gFoundCDCSSCountdown_10ms == 0)
            {
                gFoundCTCSS = false;
                gFoundCDCSS = false;
                Mode        = END_OF_RX_MODE_END;
                goto Skip;
            }
            break;
    }

    if (g_SquelchLost)
    {
#ifdef ENABLE_NOAA
        if (!gEndOfRxDetectedMaybe && !IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE))
#else
        if (!gEndOfRxDetectedMaybe)
#endif
        {
            switch (gCurrentCodeType)
            {
                case CODE_TYPE_OFF:
                    if (gEeprom.SQUELCH_LEVEL)
                    {
                        if (g_CxCSS_TAIL_Found)
                        {
                            Mode               = END_OF_RX_MODE_TTE;
                            g_CxCSS_TAIL_Found = false;
                        }
                    }
                    break;

                case CODE_TYPE_CONTINUOUS_TONE:
                    if (g_CTCSS_Lost)
                    {
                        gFoundCTCSS = false;
                    }
                    else
                    if (!gFoundCTCSS)
                    {
                        gFoundCTCSS               = true;
                        gFoundCTCSSCountdown_10ms = 100;   // 1 sec
                    }

                    if (g_CxCSS_TAIL_Found)
                    {
                        Mode               = END_OF_RX_MODE_TTE;
                        g_CxCSS_TAIL_Found = false;
                    }
                    break;

                case CODE_TYPE_DIGITAL:
                case CODE_TYPE_REVERSE_DIGITAL:
                    if (g_CDCSS_Lost && gCDCSSCodeType == CDCSS_POSITIVE_CODE)
                    {
                        gFoundCDCSS = false;
                    }
                    else
                    if (!gFoundCDCSS)
                    {
                        gFoundCDCSS               = true;
                        gFoundCDCSSCountdown_10ms = 100;   // 1 sec
                    }

                    if (g_CxCSS_TAIL_Found)
                    {
                        if (BK4819_GetCTCType() == 1)
                            Mode = END_OF_RX_MODE_TTE;

                        g_CxCSS_TAIL_Found = false;
                    }

                    break;
            }
        }
    }
    else
        Mode = END_OF_RX_MODE_END;

    if (!gEndOfRxDetectedMaybe         &&
        Mode == END_OF_RX_MODE_SKIP   &&
        gNextTimeslice40ms            &&
        gEeprom.TAIL_TONE_ELIMINATION &&
        (gCurrentCodeType == CODE_TYPE_DIGITAL || gCurrentCodeType == CODE_TYPE_REVERSE_DIGITAL) &&
        BK4819_GetCTCType() == 1)
        Mode = END_OF_RX_MODE_TTE;
    else
        gNextTimeslice40ms = false;

    Skip:
    switch (Mode)
    {
        case END_OF_RX_MODE_SKIP:
            break;

        case END_OF_RX_MODE_END:
            RADIO_SetupRegisters(true);

#ifdef ENABLE_NOAA
            if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE))
					gNOAACountdown_10ms = 300;         // 3 sec
#endif

            gUpdateDisplay = true;

            if (gScanStateDir != SCAN_OFF)
            {
                switch (gEeprom.SCAN_RESUME_MODE)
                {
                    case SCAN_RESUME_TO:
                        break;

                    case SCAN_RESUME_CO:
                        gScanPauseDelayIn_10ms = scan_pause_delay_in_7_10ms;
                        gScheduleScanListen    = false;
                        break;

                    case SCAN_RESUME_SE:
                        CHFRSCANNER_Stop();
                        break;
                }
            }

            break;

        case END_OF_RX_MODE_TTE:
            if (gEeprom.TAIL_TONE_ELIMINATION)
            {
                AUDIO_AudioPathOff();

                gTailNoteEliminationCountdown_10ms = 20;
                gFlagTailNoteEliminationComplete   = false;
                gEndOfRxDetectedMaybe = true;
                gEnableSpeaker        = false;
            }
            break;
    }
}

static void HandlePowerSave()
{
    if (!gRxIdleMode) {
        CheckForIncoming();
    }
}
static void (*HandleFunction_fn_table[])(void) = {
        [FUNCTION_FOREGROUND] = &CheckForIncoming,
        [FUNCTION_TRANSMIT] = &FUNCTION_NOP,
        [FUNCTION_MONITOR] = &FUNCTION_NOP,
        [FUNCTION_INCOMING] = &HandleIncoming,
        [FUNCTION_RECEIVE] = &HandleReceive,
        [FUNCTION_POWER_SAVE] = &HandlePowerSave,
        [FUNCTION_BAND_SCOPE] = &FUNCTION_NOP,
};

static_assert(ARRAY_SIZE(HandleFunction_fn_table) == FUNCTION_N_ELEM);

static void HandleFunction(void)
{
    HandleFunction_fn_table[gCurrentFunction]();
}

void APP_StartListening(FUNCTION_Type_t function){
    const unsigned int vfo = gEeprom.RX_VFO;
    //	const unsigned int chan = gRxVfo->CHANNEL_SAVE;

#ifdef ENABLE_DTMF_CALLING
    if (gSetting_KILLED)
		return;
#endif

#ifdef ENABLE_FMRADIO
    if (gFmRadioMode)
		BK1080_Init(0, false);
#endif

    // clear the other vfo's rssi level (to hide the antenna symbol)
    gVFO_RSSI_bar_level[!vfo] = 0;
    AUDIO_AudioPathOn();
    gEnableSpeaker = true;

        BACKLIGHT_TurnOn();

    if (gScanStateDir != SCAN_OFF)
        CHFRSCANNER_Found();

#ifdef ENABLE_NOAA
    if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE) && gIsNoaaMode) {
		gRxVfo->CHANNEL_SAVE        = gNoaaChannel + NOAA_CHANNEL_FIRST;
		gRxVfo->pRX->Frequency      = NoaaFrequencyTable[gNoaaChannel];
		gRxVfo->pTX->Frequency      = NoaaFrequencyTable[gNoaaChannel];
gEeprom.ScreenChannel[vfo] = gRxVfo->CHANNEL_SAVE;
		gNOAA_Countdown_10ms        = 500;   // 5 sec
		gScheduleNOAA               = false;
	}
#endif

    if (gScanStateDir == SCAN_OFF &&
        gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
    {	// not scanning, dual watch is enabled

        gDualWatchCountdown_10ms = dual_watch_count_after_2_10ms;
        gScheduleDualWatch       = false;

        // when crossband is active only the main VFO should be used for TX
        if(gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF)
            gRxVfoIsActive = true;

        // let the user see DW is not active
        gDualWatchActive = false;
        gUpdateStatus    = true;
    }



        BK4819_WriteRegister(BK4819_REG_48,
                             (11u << 12)                |     // ??? .. 0 to 15, doesn't seem to make any difference
                             ( 0u << 10)                |     // AF Rx Gain-1
                             (gEeprom.VOLUME_GAIN << 4) |     // AF Rx Gain-2
                             (gEeprom.DAC_GAIN    << 0));     // AF DAC Gain (after Gain-1 and Gain-2)


#ifdef ENABLE_VOICE
    if (gVoiceWriteIndex == 0)       // AM/FM RX mode will be set when the voice has finished
#endif
    RADIO_SetModulation(gRxVfo->Modulation);  // no need, set it now

    FUNCTION_Select(function);
#ifdef ENABLE_FMRADIO
    if (function == FUNCTION_MONITOR || gFmRadioMode)
#else
    if (function == FUNCTION_MONITOR)
#endif
    {	// squelch is disabled
        if (gScreenToDisplay != DISPLAY_MENU)     // 1of11 .. don't close the menu
            GUI_SelectNextDisplay(DISPLAY_MAIN);
    }
    else
        gUpdateDisplay = true;

    gUpdateStatus = true;
}

uint32_t APP_SetFreqByStepAndLimits(VFO_Info_t *pInfo, int8_t direction, uint32_t lower, uint32_t upper)
{
    uint32_t Frequency = FREQUENCY_RoundToStep(pInfo->freq_config_RX.Frequency + (direction * pInfo->StepFrequency), pInfo->StepFrequency);

    if (Frequency >= upper)
        Frequency =  lower;
    else if (Frequency < lower)
        Frequency = FREQUENCY_RoundToStep(upper - pInfo->StepFrequency, pInfo->StepFrequency);

    return Frequency;
}

uint32_t APP_SetFrequencyByStep(VFO_Info_t *pInfo, int8_t direction)
{
    return APP_SetFreqByStepAndLimits(pInfo, direction, frequencyBandTable[pInfo->Band].lower, frequencyBandTable[pInfo->Band].upper);
}

#ifdef ENABLE_NOAA
static void NOAA_IncreaseChannel(void)
	{
		if (++gNoaaChannel > 9)
			gNoaaChannel = 0;
	}
#endif

static void DualwatchAlternate(void)
{
#ifdef ENABLE_NOAA
    if (gIsNoaaMode)
		{
			if (!IS_NOAA_CHANNEL(gEeprom.ScreenChannel[0]) || !IS_NOAA_CHANNEL(gEeprom.ScreenChannel[1]))
				gEeprom.RX_VFO = (gEeprom.RX_VFO + 1) & 1;
			else
				gEeprom.RX_VFO = 0;

			gRxVfo = &gEeprom.VfoInfo[gEeprom.RX_VFO];

			if (IS_NOAA_CHANNEL(gEeprom.VfoInfo[0].CHANNEL_SAVE))
				NOAA_IncreaseChannel();
		}
		else
#endif
    {	// toggle between VFO's
        gEeprom.RX_VFO = !gEeprom.RX_VFO;
        gRxVfo         = &gEeprom.VfoInfo[gEeprom.RX_VFO];

        if (!gDualWatchActive)
        {	// let the user see DW is active
            gDualWatchActive = true;
            gUpdateStatus    = true;
        }
    }

    RADIO_SetupRegisters(false);

#ifdef ENABLE_NOAA
    gDualWatchCountdown_10ms = gIsNoaaMode ? dual_watch_count_noaa_10ms : dual_watch_count_toggle_10ms;
#else
    gDualWatchCountdown_10ms = dual_watch_count_toggle_10ms;
#endif
}
static void CheckRadioInterrupts(void)
{
    if (SCANNER_IsScanning())
        return;

    while (BK4819_ReadRegister(BK4819_REG_0C) & 1u)
    {	// BK chip interrupt request

        uint16_t interrupt_status_bits;

        // reset the interrupt ?
        BK4819_WriteRegister(BK4819_REG_02, 0);

        // fetch the interrupt status bits
        interrupt_status_bits = BK4819_ReadRegister(BK4819_REG_02);

        // 0 = no phase shift
        // 1 = 120deg phase shift
        // 2 = 180deg phase shift
        // 3 = 240deg phase shift
//		const uint8_t ctcss_shift = BK4819_GetCTCShift();
//		if (ctcss_shift > 0)
//			g_CTCSS_Lost = true;

        if (interrupt_status_bits & BK4819_REG_02_DTMF_5TONE_FOUND)
        {	// save the RX'ed DTMF character
            const char c = DTMF_GetCharacter(BK4819_GetDTMF_5TONE_Code());
            if (c != 0xff)
            {
                if (gCurrentFunction != FUNCTION_TRANSMIT)
                {
                    if (gSetting_live_DTMF_decoder)
                    {
                        size_t len = strlen(gDTMF_RX_live);
                        if (len >= (sizeof(gDTMF_RX_live) - 1))
                        {	// make room
                            memmove(&gDTMF_RX_live[0], &gDTMF_RX_live[1], sizeof(gDTMF_RX_live) - 1);
                            len--;
                        }
                        gDTMF_RX_live[len++]  = c;
                        gDTMF_RX_live[len]    = 0;
                        gDTMF_RX_live_timeout = DTMF_RX_live_timeout_500ms;  // time till we delete it
                        gUpdateDisplay        = true;
                    }

#ifdef ENABLE_DTMF_CALLING
                    if (gRxVfo->DTMF_DECODING_ENABLE || gSetting_KILLED)
					{
						if (gDTMF_RX_index >= (sizeof(gDTMF_RX) - 1))
						{	// make room
							memmove(&gDTMF_RX[0], &gDTMF_RX[1], sizeof(gDTMF_RX) - 1);
							gDTMF_RX_index--;
						}
						gDTMF_RX[gDTMF_RX_index++] = c;
						gDTMF_RX[gDTMF_RX_index]   = 0;
						gDTMF_RX_timeout           = DTMF_RX_timeout_500ms;  // time till we delete it
						gDTMF_RX_pending           = true;
                        SYSTEM_DelayMs(3);//fix DTMF not reply@Yurisu

						DTMF_HandleRequest();
					}
#endif
                }
            }
        }

        if (interrupt_status_bits & BK4819_REG_02_CxCSS_TAIL)
            g_CxCSS_TAIL_Found = true;

        if (interrupt_status_bits & BK4819_REG_02_CDCSS_LOST)
        {
            g_CDCSS_Lost = true;
            gCDCSSCodeType = BK4819_GetCDCSSCodeType();
        }

        if (interrupt_status_bits & BK4819_REG_02_CDCSS_FOUND)
            g_CDCSS_Lost = false;

        if (interrupt_status_bits & BK4819_REG_02_CTCSS_LOST)
            g_CTCSS_Lost = true;

        if (interrupt_status_bits & BK4819_REG_02_CTCSS_FOUND)
            g_CTCSS_Lost = false;

#ifdef ENABLE_VOX
        if (interrupt_status_bits & BK4819_REG_02_VOX_LOST)
		{
			g_VOX_Lost         = true;
			gVoxPauseCountdown = 10;

			if (gEeprom.VOX_SWITCH)
			{
				if (gCurrentFunction == FUNCTION_POWER_SAVE && !gRxIdleMode)
				{
					gPowerSave_10ms            = power_save2_10ms;
					gPowerSaveCountdownExpired = 0;
				}

				if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF && (gScheduleDualWatch || gDualWatchCountdown_10ms < dual_watch_count_after_vox_10ms))
				{
					gDualWatchCountdown_10ms = dual_watch_count_after_vox_10ms;
					gScheduleDualWatch = false;

					// let the user see DW is not active
					gDualWatchActive = false;
					gUpdateStatus    = true;
				}
			}
		}

		if (interrupt_status_bits & BK4819_REG_02_VOX_FOUND)
		{
			g_VOX_Lost         = false;
			gVoxPauseCountdown = 0;
		}
#endif

        if (interrupt_status_bits & BK4819_REG_02_SQUELCH_LOST)
        {
            g_SquelchLost = true;
            BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, true);
        }

        if (interrupt_status_bits & BK4819_REG_02_SQUELCH_FOUND)
        {
            g_SquelchLost = false;
            BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
        }

#ifdef ENABLE_AIRCOPY
        if (interrupt_status_bits & BK4819_REG_02_FSK_FIFO_ALMOST_FULL &&
			gScreenToDisplay == DISPLAY_AIRCOPY &&
			gAircopyState == AIRCOPY_TRANSFER &&
			gAirCopyIsSendMode == 0)
		{
			for (unsigned int i = 0; i < 4; i++) {
				g_FSK_Buffer[gFSKWriteIndex++] = BK4819_ReadRegister(BK4819_REG_5F);
			}

			AIRCOPY_StorePacket();
		}
#endif
#ifdef ENABLE_MDC1200
         MDC1200_process_rx(  interrupt_status_bits);

#endif
    }
}
void APP_EndTransmission(void)
{
    // back to RX mode
    RADIO_SendEndOfTransmission();
    gFlagEndTransmission = true;
    if (gMonitor) {
        //turn the monitor back on
        gFlagReconfigureVfos = true;
    }
}
#ifdef ENABLE_VOX
static void HandleVox(void)
{
#ifdef ENABLE_DTMF_CALLING
	if (gSetting_KILLED)
		return;
#endif

	if (gVoxResumeCountdown == 0)
	{
		if (gVoxPauseCountdown)
			return;
	}
	else
	{
		g_VOX_Lost         = false;
		gVoxPauseCountdown = 0;
	}

	#ifdef ENABLE_FMRADIO
		if (gFmRadioMode)
			return;
	#endif

	if (gCurrentFunction == FUNCTION_RECEIVE || gCurrentFunction == FUNCTION_MONITOR)
		return;

	if (gScanStateDir != SCAN_OFF)
		return;

	if (gVOX_NoiseDetected)
	{
		if (g_VOX_Lost)
			gVoxStopCountdown_10ms = vox_stop_count_down_10ms;
		else if (gVoxStopCountdown_10ms == 0)
			gVOX_NoiseDetected = false;

		if (gCurrentFunction == FUNCTION_TRANSMIT && !gPttIsPressed && !gVOX_NoiseDetected)
		{
			if (gFlagEndTransmission)
			{
				//if (gCurrentFunction != FUNCTION_FOREGROUND)
					FUNCTION_Select(FUNCTION_FOREGROUND);
			}
			else
			{
				APP_EndTransmission();

				if (gEeprom.REPEATER_TAIL_TONE_ELIMINATION == 0)
				{
					//if (gCurrentFunction != FUNCTION_FOREGROUND)
						FUNCTION_Select(FUNCTION_FOREGROUND);
				}
				else
					gRTTECountdown = gEeprom.REPEATER_TAIL_TONE_ELIMINATION * 10;
			}

			gUpdateStatus        = true;
			gUpdateDisplay       = true;
			gFlagEndTransmission = false;
		}
		return;
	}

	if (g_VOX_Lost)
	{
		gVOX_NoiseDetected = true;

		if (gCurrentFunction == FUNCTION_POWER_SAVE)
			FUNCTION_Select(FUNCTION_FOREGROUND);
if (gCurrentFunction != FUNCTION_TRANSMIT && !SerialConfigInProgress())
		{
#ifdef ENABLE_DTMF_CALLING
			gDTMF_ReplyState = DTMF_REPLY_NONE;
#endif
			RADIO_PrepareTX();
			gUpdateDisplay = true;
		}
	}
}
#endif
void APP_Update(void)
{
#ifdef ENABLE_VOICE
    if (gFlagPlayQueuedVoice) {
			AUDIO_PlayQueuedVoice();
			gFlagPlayQueuedVoice = false;
	}
#endif

    if (gCurrentFunction == FUNCTION_TRANSMIT && (gTxTimeoutReached || SerialConfigInProgress()))
    {	// transmitter timed out or must de-key
        gTxTimeoutReached = false;

        APP_EndTransmission();

        AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);

        RADIO_SetVfoState(VFO_STATE_TIMEOUT);

        GUI_DisplayScreen();
    }

    if (gReducedService)
        return;

    if (gCurrentFunction != FUNCTION_TRANSMIT)
        HandleFunction();

#ifdef ENABLE_FMRADIO
    //	if (gFmRadioCountdown_500ms > 0)
	if (gFmRadioMode && gFmRadioCountdown_500ms > 0)    // 1of11
		return;
#endif

#ifdef ENABLE_VOICE
    if (!SCANNER_IsScanning() && gScanStateDir != SCAN_OFF && gScheduleScanListen && !gPttIsPressed && gVoiceWriteIndex == 0)
#else
    if (!SCANNER_IsScanning() && gScanStateDir != SCAN_OFF && gScheduleScanListen && !gPttIsPressed)
#endif
    {	// scanning
        CHFRSCANNER_ContinueScanning();
    }

#ifdef ENABLE_NOAA
    #ifdef ENABLE_VOICE
		if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF && gIsNoaaMode && gScheduleNOAA && gVoiceWriteIndex == 0)
#else
		if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF && gIsNoaaMode && gScheduleNOAA)
#endif
		{
			NOAA_IncreaseChannel();
			RADIO_SetupRegisters(false);

			gNOAA_Countdown_10ms = 7;      // 70ms
			gScheduleNOAA        = false;
		}
#endif

    // toggle between the VFO's if dual watch is enabled
    if (!SCANNER_IsScanning()
        && gEeprom.DUAL_WATCH != DUAL_WATCH_OFF
        && gScheduleDualWatch
        && gScanStateDir == SCAN_OFF
        && !gPttIsPressed
        && gCurrentFunction != FUNCTION_POWER_SAVE
#ifdef ENABLE_VOICE
        && gVoiceWriteIndex == 0
#endif
#ifdef ENABLE_FMRADIO
        && !gFmRadioMode
#endif
#ifdef ENABLE_DTMF_CALLING
        && gDTMF_CallState == DTMF_CALL_STATE_NONE
#endif
            ) {
        DualwatchAlternate();    // toggle between the two VFO's

        if (gRxVfoIsActive && gScreenToDisplay == DISPLAY_MAIN) {
            GUI_SelectNextDisplay(DISPLAY_MAIN);
        }

        gRxVfoIsActive     = false;
        gScanPauseMode     = false;
        gRxReceptionMode   = RX_MODE_NONE;
        gScheduleDualWatch = false;
    }

#ifdef ENABLE_FMRADIO
    if (gScheduleFM && gFM_ScanState != FM_SCAN_OFF && !FUNCTION_IsRx()) {
		// switch to FM radio mode
		FM_Play();
		gScheduleFM = false;
	}
#endif

#ifdef ENABLE_VOX
    if (gEeprom.VOX_SWITCH)
		HandleVox();
#endif

    if (gSchedulePowerSave) {
        if (gPttIsPressed
            || gKeyBeingHeld
            || gEeprom.BATTERY_SAVE == 0
            || gScanStateDir != SCAN_OFF
            || gCssBackgroundScan
            || gScreenToDisplay != DISPLAY_MAIN
#ifdef ENABLE_FMRADIO
            || gFmRadioMode
#endif
#ifdef ENABLE_DTMF_CALLING
            || gDTMF_CallState != DTMF_CALL_STATE_NONE
#endif


#ifdef ENABLE_NOAA
            || (gIsNoaaMode && (IS_NOAA_CHANNEL(gEeprom.ScreenChannel[0]) || IS_NOAA_CHANNEL(gEeprom.ScreenChannel[1])))
#endif
                ) {
            gBatterySaveCountdown_10ms = battery_save_count_10ms;
        } else {
            FUNCTION_Select(FUNCTION_POWER_SAVE);
        }

        gSchedulePowerSave = false;
    }

    if (gPowerSaveCountdownExpired && gCurrentFunction == FUNCTION_POWER_SAVE
#ifdef ENABLE_VOICE
        && gVoiceWriteIndex == 0
#endif
            )
    {
        static bool goToSleep;
        // wake up, enable RX then go back to sleep
        if (gRxIdleMode)
        {
            BK4819_Conditional_RX_TurnOn_and_GPIO6_Enable();

#ifdef ENABLE_VOX
            if (gEeprom.VOX_SWITCH)
				BK4819_EnableVox(gEeprom.VOX1_THRESHOLD, gEeprom.VOX0_THRESHOLD);
#endif

            if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF &&
                gScanStateDir == SCAN_OFF &&
                !gCssBackgroundScan)
            {	// dual watch mode, toggle between the two VFO's
                DualwatchAlternate();
                goToSleep = false;
            }

            FUNCTION_Init();

            gPowerSave_10ms = power_save1_10ms; // come back here in a bit
            gRxIdleMode     = false;            // RX is awake
        }
        else if (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF || gScanStateDir != SCAN_OFF || gCssBackgroundScan || goToSleep)
        {	// dual watch mode off or scanning or rssi update request
            // go back to sleep

            gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10;
            gRxIdleMode     = true;
            goToSleep = false;

            BK4819_DisableVox();
            BK4819_Sleep();
            BK4819_ToggleGpioOut(BK4819_GPIO0_PIN28_RX_ENABLE, false);

            // Authentic device checked removed

        }
        else {
            // toggle between the two VFO's
            DualwatchAlternate();
            gPowerSave_10ms   = power_save1_10ms;
            goToSleep = true;
        }

        gPowerSaveCountdownExpired = false;
    }
}

// called every 10ms
static void CheckKeys(void)
{
#ifdef ENABLE_DTMF_CALLING
    if(gSetting_KILLED){
		return;
	}
#endif

#ifdef ENABLE_AIRCOPY
    if (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState != AIRCOPY_READY){
		return;
	}
#endif


// -------------------- PTT ------------------------
    if (gPttIsPressed)
    {

            if (GPIO_CheckBit(&GPIOC->DATA, GPIOC_PIN_PTT) || SerialConfigInProgress())
        {	// PTT released or serial comms config in progress
            if (++gPttDebounceCounter >= 3 || SerialConfigInProgress())	    // 30ms
            {	// stop transmitting
                ProcessKey(KEY_PTT, false, false);
                gPttIsPressed = false;
                if (gKeyReading1 != KEY_INVALID)
                    gPttWasReleased = true;
            }
        }
        else
            gPttDebounceCounter = 0;
    }
    else if (!GPIO_CheckBit(&GPIOC->DATA, GPIOC_PIN_PTT) && !SerialConfigInProgress())
    {	// PTT pressed
        if (++gPttDebounceCounter >= 3)	    // 30ms
        {	// start transmitting
            boot_counter_10ms   = 0;
            gPttDebounceCounter = 0;
            gPttIsPressed       = true;
            ProcessKey(KEY_PTT, true, false);
        }
    }
    else
        gPttDebounceCounter = 0;

// --------------------- OTHER KEYS ----------------------------

    // scan the hardware keys
    KEY_Code_t Key = KEYBOARD_Poll();

    if (Key != KEY_INVALID) // any key pressed
        boot_counter_10ms = 0;   // cancel boot screen/beeps if any key pressed

    if (gKeyReading0 != Key) // new key pressed
    {

        if (gKeyReading0 != KEY_INVALID && Key != KEY_INVALID)
            ProcessKey(gKeyReading1, false, gKeyBeingHeld);  // key pressed without releasing previous key

        gKeyReading0     = Key;
        gDebounceCounter = 0;
        return;
    }

    gDebounceCounter++;

    if (gDebounceCounter == key_debounce_10ms) // debounced new key pressed
    {
        if (Key == KEY_INVALID) //all non PTT keys released
        {
            if (gKeyReading1 != KEY_INVALID) // some button was pressed before
            {
                ProcessKey(gKeyReading1, false, gKeyBeingHeld); // process last button released event
                gKeyReading1 = KEY_INVALID;
            }
        }
        else // process new key pressed
        {
            gKeyReading1 = Key;
            ProcessKey(Key, true, false);
        }

        gKeyBeingHeld = false;
        return;
    }

    if (gDebounceCounter < key_repeat_delay_10ms || Key == KEY_INVALID) // the button is not held long enough for repeat yet, or not really pressed
        return;

    if (gDebounceCounter == key_repeat_delay_10ms) //initial key repeat with longer delay
    {
        if (Key != KEY_PTT)
        {
            gKeyBeingHeld = true;
            ProcessKey(Key, true, true); // key held event
        }
    }
    else //subsequent fast key repeats
    {
        if (Key == KEY_UP || Key == KEY_DOWN) // fast key repeats for up/down buttons
        {
            gKeyBeingHeld = true;
            if ((gDebounceCounter % key_repeat_10ms) == 0)
                ProcessKey(Key, true, true); // key held event
        }

        if (gDebounceCounter < 0xFFFF)
            return;

        gDebounceCounter = key_repeat_delay_10ms+1;
    }
}

void APP_TimeSlice10ms(void)
{
    gNextTimeslice = false;
    gFlashLightBlinkCounter++;
#ifdef ENABLE_BOOT_BEEPS
    if (boot_counter_10ms > 0 && (boot_counter_10ms % 25) == 0) {
		AUDIO_PlayBeep(BEEP_880HZ_40MS_OPTIONAL);
	}
#endif

#ifdef ENABLE_AM_FIX
    if (gRxVfo->Modulation == MODULATION_AM) {
		AM_fix_10ms(gEeprom.RX_VFO);
	}
#endif

#ifdef ENABLE_UART
    if (UART_IsCommandAvailable()) {

        __disable_irq();
        UART_HandleCommand();
        __enable_irq();
    }
#endif
    if (gReducedService)
        return;

    if (gCurrentFunction != FUNCTION_POWER_SAVE || !gRxIdleMode)
        CheckRadioInterrupts();

    if (gCurrentFunction == FUNCTION_TRANSMIT)
    {	// transmitting
//#ifdef ENABLE_AUDIO_BAR
        if ( (gFlashLightBlinkCounter % (150 / 10)) == 0) // once every 150ms
				UI_DisplayAudioBar();
//#endif
    }

    if (gUpdateDisplay)
    {
        gUpdateDisplay = false;
        GUI_DisplayScreen();
    }

    if (gUpdateStatus)
        UI_DisplayStatus();

    // Skipping authentic device checks

#ifdef ENABLE_FMRADIO
    if (gFmRadioMode && gFmRadioCountdown_500ms > 0)   // 1of11
			return;
#endif

    FlashlightTimeSlice();

#ifdef ENABLE_VOX
    if (gVoxResumeCountdown > 0)
			gVoxResumeCountdown--;

		if (gVoxPauseCountdown > 0)
			gVoxPauseCountdown--;
#endif

    if (gCurrentFunction == FUNCTION_TRANSMIT)
    {
#ifdef ENABLE_ALARM
        if (gAlarmState == ALARM_STATE_TXALARM || gAlarmState == ALARM_STATE_SITE_ALARM)

			{
				uint16_t Tone;

				gAlarmRunningCounter++;
				gAlarmToneCounter++;

				Tone = 500 + (gAlarmToneCounter * 25);
				if (Tone > 1500)
				{
					Tone              = 500;
					gAlarmToneCounter = 0;
				}

				BK4819_SetScrambleFrequencyControlWord(Tone);

				if (gEeprom.ALARM_MODE == ALARM_MODE_TONE && gAlarmRunningCounter == 512)
				{
					gAlarmRunningCounter = 0;

					if (gAlarmState == ALARM_STATE_TXALARM)
					{
gAlarmState = ALARM_STATE_SITE_ALARM;
						RADIO_EnableCxCSS();
						BK4819_SetupPowerAmplifier(0, 0);
						BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
						BK4819_Enable_AfDac_DiscMode_TxDsp();
						BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false);

						GUI_DisplayScreen();
					}
					else
					{
						gAlarmState = ALARM_STATE_TXALARM;

						GUI_DisplayScreen();

						BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true);
						RADIO_SetTxParameters();
						BK4819_TransmitTone(true, 500);
						SYSTEM_DelayMs(2);
						AUDIO_AudioPathOn();

						gEnableSpeaker    = true;
						gAlarmToneCounter = 0;
					}
				}
			}
#endif

        // repeater tail tone elimination
        if (gRTTECountdown > 0)
        {
            if (--gRTTECountdown == 0)
            {
                //if (gCurrentFunction != FUNCTION_FOREGROUND)
                FUNCTION_Select(FUNCTION_FOREGROUND);

                gUpdateStatus  = true;
                gUpdateDisplay = true;
            }
        }
    }

#ifdef ENABLE_FMRADIO
    if (gFmRadioMode && gFM_RestoreCountdown_10ms > 0)
	{
		if (--gFM_RestoreCountdown_10ms == 0)
		{	// switch back to FM radio mode
			FM_Start();
			GUI_SelectNextDisplay(DISPLAY_FM);
		}
	}
#endif


    SCANNER_TimeSlice10ms();

#ifdef ENABLE_AIRCOPY
    if (gScreenToDisplay == DISPLAY_AIRCOPY && gAircopyState == AIRCOPY_TRANSFER && gAirCopyIsSendMode == 1)
	{
		if (!AIRCOPY_SendMessage()) {
			GUI_DisplayScreen();
		}
	}
#endif

    CheckKeys();
}

void cancelUserInputModes(void)
{
    if (gDTMF_InputMode || gDTMF_InputBox_Index > 0)
    {
        DTMF_clear_input_box();
        gBeepToPlay           = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
        gRequestDisplayScreen = DISPLAY_MAIN;
        gUpdateDisplay        = true;
    }

    if (gWasFKeyPressed || gKeyInputCountdown > 0 || gInputBoxIndex > 0)
    {
        gWasFKeyPressed     = false;
        gInputBoxIndex      = 0;
        gKeyInputCountdown  = 0;
        gBeepToPlay         = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
        gUpdateStatus       = true;
        gUpdateDisplay      = true;
    }
}

// this is called once every 500ms
void APP_TimeSlice500ms(void)
{
    gNextTimeslice_500ms = false;
    bool exit_menu = false;

    // Skipped authentic device check

    if (gKeypadLocked > 0)
        if (--gKeypadLocked == 0)
            gUpdateDisplay = true;

    if (gKeyInputCountdown > 0)
    {
        if (--gKeyInputCountdown == 0)
        {
            cancelUserInputModes();

            if (gBeepToPlay != BEEP_NONE)
            {
                AUDIO_PlayBeep(gBeepToPlay);
                gBeepToPlay = BEEP_NONE;
            }
        }
    }

    if (gDTMF_RX_live_timeout > 0)
    {
#ifdef ENABLE_RSSI_BAR
        if (center_line == CENTER_LINE_DTMF_DEC ||
				center_line == CENTER_LINE_NONE)  // wait till the center line is free for us to use before timing out
#endif
        {
            if (--gDTMF_RX_live_timeout == 0)
            {
                if (gDTMF_RX_live[0] != 0)
                {
                    memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));
                    gUpdateDisplay   = true;
                }
            }
        }
    }

    if (gMenuCountdown > 0)
        if (--gMenuCountdown == 0)
            exit_menu = (gScreenToDisplay == DISPLAY_MENU);	// exit menu mode

#ifdef ENABLE_DTMF_CALLING
    if (gDTMF_RX_timeout > 0)
		if (--gDTMF_RX_timeout == 0)
			DTMF_clear_RX();
#endif
#ifdef ENABLE_MDC1200
    if (mdc1200_rx_ready_tick_500ms > 0)
		{
			if (--mdc1200_rx_ready_tick_500ms == 0)
			{
				if (center_line == CENTER_LINE_MDC1200)
					center_line = CENTER_LINE_NONE;
				gUpdateDisplay = true;
			}
		}
#endif
#ifdef ENABLE_FMRADIO
    if (gFmRadioCountdown_500ms > 0)
	{
		gFmRadioCountdown_500ms--;
		if (gFmRadioMode)           // 1of11
			return;
	}
#endif

        if (gBacklightCountdown_500ms > 0 && !gAskToSave && !gCssBackgroundScan
        // don't turn off backlight if user is in backlight menu option
    && !(gScreenToDisplay == DISPLAY_MENU && (UI_MENU_GetCurrentMenuId() == MENU_ABR || UI_MENU_GetCurrentMenuId() == MENU_ABR_MAX))
       && --gBacklightCountdown_500ms == 0
       && gEeprom.BACKLIGHT_TIME < (ARRAY_SIZE(gSubMenu_BACKLIGHT) - 1)
                ) {
            BACKLIGHT_TurnOff();


    }
    if (gReducedService)
    {
        BOARD_ADC_GetBatteryInfo(&gBatteryCurrentVoltage, &gBatteryCurrent);

        if (gBatteryCurrent > 500 || gBatteryCalibration[3] < gBatteryCurrentVoltage)
        {
#ifdef ENABLE_OVERLAY
            overlay_FLASH_RebootToBootloader();
#else
            NVIC_SystemReset();
#endif
        }

        return;
    }

    gBatteryCheckCounter++;

    // Skipped authentic device check

    if (gCurrentFunction != FUNCTION_TRANSMIT)
    {

        if ((gBatteryCheckCounter & 1) == 0)
        {
            BOARD_ADC_GetBatteryInfo(&gBatteryVoltages[gBatteryVoltageIndex++], &gBatteryCurrent);
            if (gBatteryVoltageIndex > 3)
                gBatteryVoltageIndex = 0;
            BATTERY_GetReadings(true);
        }
    }

    // regular display updates (once every 2 sec) - if need be
    if ((gBatteryCheckCounter & 3) == 0)
    {
        if (gChargingWithTypeC )
            gUpdateStatus = true;
#ifdef ENABLE_SHOW_CHARGE_LEVEL
        if (gChargingWithTypeC)
				gUpdateDisplay = true;
#endif
    }

    if (!gCssBackgroundScan && gScanStateDir == SCAN_OFF && !SCANNER_IsScanning()
#ifdef ENABLE_FMRADIO
        && (gFM_ScanState == FM_SCAN_OFF || gAskToSave)
#endif
#ifdef ENABLE_AIRCOPY
        && gScreenToDisplay != DISPLAY_AIRCOPY
#endif
            ) {


        if (exit_menu) {
            gMenuCountdown = 0;

            if (gEeprom.BACKLIGHT_TIME == 0) {
                BACKLIGHT_TurnOff();
            }

            if (gInputBoxIndex > 0 || gDTMF_InputMode) {
                AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
            }
/*
			if (SCANNER_IsScanning()) {
				BK4819_StopScan();
				RADIO_ConfigureChannel(0, VFO_CONFIGURE_RELOAD);
				RADIO_ConfigureChannel(1, VFO_CONFIGURE_RELOAD);
				RADIO_SetupRegisters(true);
			}
*/
            DTMF_clear_input_box();

            gWasFKeyPressed  = false;
            gInputBoxIndex   = 0;

            gAskToSave       = false;
            gAskToDelete     = false;

            gUpdateStatus    = true;
            gUpdateDisplay   = true;

            GUI_DisplayType_t disp = DISPLAY_INVALID;

#ifdef ENABLE_FMRADIO
            if (gFmRadioMode && ! FUNCTION_IsRx()) {
				disp = DISPLAY_FM;
			}
#endif

            if (disp == DISPLAY_INVALID
                #ifndef ENABLE_NO_CODE_SCAN_TIMEOUT
                && !SCANNER_IsScanning()
#endif
                    ) {
                disp = DISPLAY_MAIN;
            }

            if (disp != DISPLAY_INVALID) {
                GUI_SelectNextDisplay(disp);
            }
        }
    }

    if (!gPttIsPressed && gVFOStateResumeCountdown_500ms > 0 && --gVFOStateResumeCountdown_500ms == 0) {
        RADIO_SetVfoState(VFO_STATE_NORMAL);
#ifdef ENABLE_FMRADIO
        if (gFmRadioMode && !FUNCTION_IsRx()) {
			// switch back to FM radio mode
			FM_Start();
			GUI_SelectNextDisplay(DISPLAY_FM);
		}
#endif
    }
    BATTERY_TimeSlice500ms();
    SCANNER_TimeSlice500ms();
    UI_MAIN_TimeSlice500ms();
#ifdef ENABLE_DTMF_CALLING
        if (gCurrentFunction != FUNCTION_TRANSMIT) {
		if (gDTMF_DecodeRingCountdown_500ms > 0) {
			// make "ring-ring" sound
			gDTMF_DecodeRingCountdown_500ms--;
			AUDIO_PlayBeep(BEEP_880HZ_200MS);
		}
	} else {
		gDTMF_DecodeRingCountdown_500ms = 0;
}
	if (gDTMF_CallState  != DTMF_CALL_STATE_NONE && gCurrentFunction != FUNCTION_TRANSMIT
		&& gCurrentFunction != FUNCTION_RECEIVE && gDTMF_auto_reset_time_500ms > 0
		&& --gDTMF_auto_reset_time_500ms == 0)
	{
		gUpdateDisplay  = true;
		if (gDTMF_CallState == DTMF_CALL_STATE_RECEIVED && gEeprom.DTMF_auto_reset_time >= DTMF_HOLD_MAX) {
			gDTMF_CallState = DTMF_CALL_STATE_RECEIVED_STAY;     // keep message on-screen till a key is pressed
		} else {
			gDTMF_CallState = DTMF_CALL_STATE_NONE;
		}
	}

	if (gDTMF_IsTx && gDTMF_TxStopCountdown_500ms > 0 && --gDTMF_TxStopCountdown_500ms == 0) {
		gDTMF_IsTx     = false;
		gUpdateDisplay = true;
	}
#endif
}

#if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
static void ALARM_Off(void)
{
	AUDIO_AudioPathOff();
	gEnableSpeaker = false;

if (gAlarmState == ALARM_STATE_TXALARM || gAlarmState == ALARM_STATE_TX1750) {
    RADIO_SendEndOfTransmission();
	}

	gAlarmState = ALARM_STATE_OFF;

#ifdef ENABLE_VOX
	gVoxResumeCountdown = 80;
#endif

	SYSTEM_DelayMs(5);

	RADIO_SetupRegisters(true);

	if (gScreenToDisplay != DISPLAY_MENU)     // 1of11 .. don't close the menu
		gRequestDisplayScreen = DISPLAY_MAIN;
}
#endif



static void ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
{
    if (Key == KEY_EXIT && !BACKLIGHT_IsOn() && gEeprom.BACKLIGHT_TIME > 0)
    {	// just turn the light on for now so the user can see what's what
        BACKLIGHT_TurnOn();
        gBeepToPlay = BEEP_NONE;
        return;
    }

    if (gCurrentFunction == FUNCTION_POWER_SAVE)
        FUNCTION_Select(FUNCTION_FOREGROUND);

    gBatterySaveCountdown_10ms = battery_save_count_10ms;



    if (!bKeyPressed) // key released
    {
        if (gFlagSaveVfo)
        {
            SETTINGS_SaveVfoIndices();
            gFlagSaveVfo = false;
        }

        if (gFlagSaveSettings)
        {
            SETTINGS_SaveSettings();
            gFlagSaveSettings = false;
        }

#ifdef ENABLE_FMRADIO
        if (gFlagSaveFM)
			{
				SETTINGS_SaveFM();
				gFlagSaveFM = false;
			}
#endif

        if (gFlagSaveChannel)
        {
            SETTINGS_SaveChannel(gTxVfo->CHANNEL_SAVE, gEeprom.TX_VFO, gTxVfo, gFlagSaveChannel);
            gFlagSaveChannel = false;

            if (!SCANNER_IsScanning() && gVfoConfigureMode == VFO_CONFIGURE_NONE)
                // gVfoConfigureMode is so as we don't wipe out previously setting this variable elsewhere
                gVfoConfigureMode = VFO_CONFIGURE;
        }

#ifdef ENABLE_SIDEFUNCTIONS_SEND
		if (gFlagStopTX)
		{
			gFlagStopTX = false;
            APP_EndTransmission();
			RADIO_SetupRegisters(true);
			GUI_SelectNextDisplay(DISPLAY_MAIN);
			gEeprom.TX_VFO = gFlagLastVfo;
			gFlagReconfigureVfos = true;
			gUpdateDisplay = true;
			return;
		}
#endif
    }
    else // key pressed or held
    {
      //  const uint8_t s = BACKLIGHT_ON_TR_TXRX;
        const int m = UI_MENU_GetCurrentMenuId();
        if 	(	//not when PTT and the backlight shouldn't turn on on TX
            /*    !(Key == KEY_PTT && s != BACKLIGHT_ON_TR_TX && s != BACKLIGHT_ON_TR_TXRX)
                // not in the backlight menu
                &&*/ !(gScreenToDisplay == DISPLAY_MENU && ( m == MENU_ABR || m == MENU_ABR_MAX ))
                )
        {
            BACKLIGHT_TurnOn();
        }

        if (Key == KEY_EXIT && bKeyHeld)
        {	// exit key held pressed

            // clear the live DTMF decoder
            if (gDTMF_RX_live[0] != 0)
            {
                memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));
                gDTMF_RX_live_timeout = 0;
                gUpdateDisplay        = true;
            }

            // cancel user input
            cancelUserInputModes();

            if (gMonitor)
                ACTION_Monitor(); //turn off the monitor
#ifdef ENABLE_SCAN_RANGES
            gScanRangeStart = 0;
#endif
        }

        if (gScreenToDisplay == DISPLAY_MENU)       // 1of11
            gMenuCountdown = menu_timeout_500ms;

#ifdef ENABLE_DTMF_CALLING
        if (gDTMF_DecodeRingCountdown_500ms > 0)
		{	// cancel the ringing
			gDTMF_DecodeRingCountdown_500ms = 0;

			AUDIO_PlayBeep(BEEP_1KHZ_60MS_OPTIONAL);

			if (Key != KEY_PTT)
			{
				gPttWasReleased = true;
				return;
			}
		}
#endif
    }

    bool lowBatPopup = gLowBattery && !gLowBatteryConfirmed &&  gScreenToDisplay == DISPLAY_MAIN;

    if ((gEeprom.KEY_LOCK || lowBatPopup) && gCurrentFunction != FUNCTION_TRANSMIT && Key != KEY_PTT)
    {	// keyboard is locked or low battery popup

        // close low battery popup
        if(Key == KEY_EXIT && bKeyPressed && lowBatPopup) {
            gLowBatteryConfirmed = true;
            gUpdateDisplay = true;
            AUDIO_PlayBeep(BEEP_1KHZ_60MS_OPTIONAL);
            return;
        }

        if (Key == KEY_F)
        {	// function/key-lock key

            if (!bKeyPressed)
                return;

            if (!bKeyHeld)
            {	// keypad is locked, tell the user
                AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
                gKeypadLocked  = 4;      // 2 seconds
                gUpdateDisplay = true;
                return;
            }
        }
            // KEY_MENU has a special treatment here, because we want to pass hold event to ACTION_Handle
            // but we don't want it to complain when initial press happens
            // we want to react on realese instead
            // KEY_MENU has a special treatment here, because we want to pass hold event to ACTION_Handle
            // but we don't want it to complain when initial press happens
            // we want to react on realese instead
#ifdef ENABLE_CUSTOM_SIDEFUNCTIONS
        else if (Key != KEY_SIDE1 && Key != KEY_SIDE2 &&        // pass side buttons
                 !(Key == KEY_MENU && bKeyHeld && gEeprom.KEY_M_LONG_PRESS_ACTION == ACTION_OPT_KEYLOCK)) // pass KEY_MENU held
#else
        else if (Key != KEY_SIDE1 && Key != KEY_SIDE2) // pass KEY_MENU held
#endif
        {
            // keypad is locked, tell the user
            AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
            gKeypadLocked  = 4;          // 2 seconds
            gUpdateDisplay = true;
            return;
        }
    }

    if (Key <= KEY_9 || Key == KEY_F)
    {
        if (gScanStateDir != SCAN_OFF || gCssBackgroundScan)
        {	// FREQ/CTCSS/DCS scanning
            if (bKeyPressed && !bKeyHeld)
                AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
            return;
        }
    }

    bool bFlag = false;
    if (Key == KEY_PTT)
    {
//        if(gEeprom.KEY_LOCK)
//        {
//            gKeypadLocked  = 4;          // 2 seconds
//            return;
//        }
        if (gPttWasPressed)
        {
            bFlag = bKeyHeld;
            if (!bKeyPressed)
            {
                bFlag          = true;
                gPttWasPressed = false;



            }
        }
    }
    else if (gPttWasReleased)
    {
        if (bKeyHeld)
            bFlag = true;
        if (!bKeyPressed)
        {
            bFlag           = true;
            gPttWasReleased = false;
        }
    }

    if (gWasFKeyPressed && (Key == KEY_PTT || Key == KEY_EXIT || Key == KEY_SIDE1 || Key == KEY_SIDE2))
    {	// cancel the F-key
        gWasFKeyPressed = false;
        gUpdateStatus   = true;
    }

    if (bFlag) {
        goto Skip;
    }
    if (gCurrentFunction == FUNCTION_TRANSMIT) {
#if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
        if (gAlarmState == ALARM_STATE_OFF)
#endif
        {
            char Code;

            if (Key == KEY_PTT)
            {
                GENERIC_Key_PTT(bKeyPressed);
                goto Skip;
            }

            if (Key == KEY_SIDE2)
            {	// transmit 1750Hz tone
                Code = 0xFE;
            }
            else
            {

                Code = DTMF_GetCharacter(Key - KEY_0);
                if (Code == 0xFF)
                    goto Skip;

                // transmit DTMF keys
            }

            if (!bKeyPressed || bKeyHeld)
            {
                if (!bKeyPressed)
                {
                    AUDIO_AudioPathOff();

                    gEnableSpeaker = false;

                    BK4819_ExitDTMF_TX(false);

                    if (gCurrentVfo->SCRAMBLING_TYPE == 0 || !gSetting_ScrambleEnable)
                        BK4819_DisableScramble();
                    else
                        BK4819_EnableScramble(gCurrentVfo->SCRAMBLING_TYPE - 1);
                }
            }
            else
            {
                if (gEeprom.DTMF_SIDE_TONE)
                {	// user will here the DTMF tones in speaker
                    AUDIO_AudioPathOn();
                    gEnableSpeaker = true;
                }

                BK4819_DisableScramble();

                if (Code == 0xFE)
                    BK4819_TransmitTone(gEeprom.DTMF_SIDE_TONE, 1750);
                else
                    BK4819_PlayDTMFEx(gEeprom.DTMF_SIDE_TONE, Code);
            }
        }
#if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
        else if ((!bKeyHeld && bKeyPressed) || (gAlarmState == ALARM_STATE_TX1750 && bKeyHeld && !bKeyPressed)) {
			ALARM_Off();

			if (gEeprom.REPEATER_TAIL_TONE_ELIMINATION == 0)
				FUNCTION_Select(FUNCTION_FOREGROUND);
			else
				gRTTECountdown = gEeprom.REPEATER_TAIL_TONE_ELIMINATION * 10;

			if (Key == KEY_PTT)
				gPttWasPressed  = true;
			else
			if (!bKeyHeld)
				gPttWasReleased = true;
		}
#endif
    }
    else if (Key != KEY_SIDE1 && Key != KEY_SIDE2 && gScreenToDisplay != DISPLAY_INVALID) {
        ProcessKeysFunctions[gScreenToDisplay](Key, bKeyPressed, bKeyHeld);
    }
    else if (!SCANNER_IsScanning()
#ifdef ENABLE_AIRCOPY
        && gScreenToDisplay != DISPLAY_AIRCOPY
#endif
            ) {
        ACTION_Handle(Key, bKeyPressed, bKeyHeld);
    }
    else if (!bKeyHeld && bKeyPressed) {
        gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
    }

    Skip:
    if (gBeepToPlay != BEEP_NONE)
    {
        AUDIO_PlayBeep(gBeepToPlay);
        gBeepToPlay = BEEP_NONE;
    }

    if (gFlagAcceptSetting)
    {
        gMenuCountdown = menu_timeout_500ms;

        MENU_AcceptSetting();

        gFlagRefreshSetting = true;
        gFlagAcceptSetting  = false;
    }

    if (gRequestSaveSettings)
    {
        if (!bKeyHeld)
            SETTINGS_SaveSettings();
        else
            gFlagSaveSettings = 1;
        gRequestSaveSettings = false;
        gUpdateStatus        = true;
    }
#ifdef ENABLE_FMRADIO
    if (gRequestSaveFM)
	{
		gRequestSaveFM = false;
		if (!bKeyHeld)
			SETTINGS_SaveFM();
		else
			gFlagSaveFM = true;
	}
#endif

    if (gRequestSaveVFO)
    {
        gRequestSaveVFO = false;
        if (!bKeyHeld)
            SETTINGS_SaveVfoIndices();
        else
            gFlagSaveVfo = true;
    }

    if (gRequestSaveChannel > 0)
    {
        if (!bKeyHeld)// TODO: remove the gRequestSaveChannel, why use global variable for that??
        {
            SETTINGS_SaveChannel(gTxVfo->CHANNEL_SAVE, gEeprom.TX_VFO, gTxVfo, gRequestSaveChannel);

            if (!SCANNER_IsScanning())
                if (gVfoConfigureMode == VFO_CONFIGURE_NONE)  // 'if' is so as we don't wipe out previously setting this variable elsewhere
                    gVfoConfigureMode = VFO_CONFIGURE;
        }
        else
        {
            gFlagSaveChannel = gRequestSaveChannel;

            if (gRequestDisplayScreen == DISPLAY_INVALID)
                gRequestDisplayScreen = DISPLAY_MAIN;
        }

        gRequestSaveChannel = 0;
    }

    if (gVfoConfigureMode != VFO_CONFIGURE_NONE)
    {
        if (gFlagResetVfos)
        {
            RADIO_ConfigureChannel(0, gVfoConfigureMode);
            RADIO_ConfigureChannel(1, gVfoConfigureMode);
        }
        else
            RADIO_ConfigureChannel(gEeprom.TX_VFO, gVfoConfigureMode);

        if (gRequestDisplayScreen == DISPLAY_INVALID)
            gRequestDisplayScreen = DISPLAY_MAIN;

        gFlagReconfigureVfos = true;
        gVfoConfigureMode    = VFO_CONFIGURE_NONE;
        gFlagResetVfos       = false;
    }

    if (gFlagReconfigureVfos)
    {
        RADIO_SelectVfos();

#ifdef ENABLE_NOAA
        RADIO_ConfigureNOAA();
#endif

        RADIO_SetupRegisters(true);

#ifdef ENABLE_DTMF_CALLING
        gDTMF_auto_reset_time_500ms = 0;
		gDTMF_CallState             = DTMF_CALL_STATE_NONE;
		gDTMF_TxStopCountdown_500ms = 0;
		gDTMF_IsTx                  = false;
#endif

        gVFO_RSSI_bar_level[0]      = 0;
        gVFO_RSSI_bar_level[1]      = 0;

        gFlagReconfigureVfos        = false;

        if (gMonitor)
            ACTION_Monitor();   // 1of11
    }

    if (gFlagRefreshSetting)
    {
        gFlagRefreshSetting = false;
        gMenuCountdown      = menu_timeout_500ms;

        MENU_ShowCurrentSetting();
    }

    if (gFlagPrepareTX)
    {
        RADIO_PrepareTX();
        gFlagPrepareTX = false;
    }

#ifdef ENABLE_VOICE
    if (gAnotherVoiceID != VOICE_ID_INVALID)
		{
			if (gAnotherVoiceID < 76)
				AUDIO_SetVoiceID(0, gAnotherVoiceID);
			AUDIO_PlaySingleVoice(false);
			gAnotherVoiceID = VOICE_ID_INVALID;
		}
#endif

    GUI_SelectNextDisplay(gRequestDisplayScreen);
    gRequestDisplayScreen = DISPLAY_INVALID;

    gUpdateDisplay = true;
}