/* 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 <string.h>

#include "app/dtmf.h"

#if defined(ENABLE_FMRADIO)

#include "app/fm.h"

#endif

#include "audio.h"
#include "bsp/dp32g030/gpio.h"
#include "dcs.h"
#include "driver/backlight.h"

#if defined(ENABLE_FMRADIO)

#include "driver/bk1080.h"

#endif

#include "driver/bk4819.h"
#include "driver/gpio.h"
#include "driver/system.h"
#include "driver/st7565.h"
#include "frequencies.h"
#include "functions.h"
#include "helper/battery.h"
#include "misc.h"
#include "radio.h"
#include "settings.h"
#include "ui/status.h"
#include "ui/ui.h"
#include "app/app.h"
#include "driver/systick.h"


FUNCTION_Type_t gCurrentFunction;

bool FUNCTION_IsRx() {
    return gCurrentFunction == FUNCTION_MONITOR ||
           gCurrentFunction == FUNCTION_INCOMING ||
           gCurrentFunction == FUNCTION_RECEIVE;
}

void FUNCTION_Init(void) {
    g_CxCSS_TAIL_Found = false;
    g_CDCSS_Lost = false;
    g_CTCSS_Lost = false;

    g_SquelchLost = false;

    gFlagTailNoteEliminationComplete = false;
    gTailNoteEliminationCountdown_10ms = 0;
    gFoundCTCSS = false;
    gFoundCDCSS = false;
    gFoundCTCSSCountdown_10ms = 0;
    gFoundCDCSSCountdown_10ms = 0;
    gEndOfRxDetectedMaybe = false;

    gCurrentCodeType = (gRxVfo->Modulation != MODULATION_FM) ? CODE_TYPE_OFF : gRxVfo->pRX->CodeType;

#ifdef ENABLE_VOX
    g_VOX_Lost = false;
#endif

#ifdef ENABLE_DTMF_CALLING
    DTMF_clear_RX();
#endif

#ifdef ENABLE_NOAA
    gNOAACountdown_10ms = 0;

    if (IS_NOAA_CHANNEL(gRxVfo->CHANNEL_SAVE)) {
        gCurrentCodeType = CODE_TYPE_OFF;
    }
#endif

    gUpdateStatus = true;
}

void FUNCTION_Foreground(const FUNCTION_Type_t PreviousFunction) {
#ifdef ENABLE_DTMF_CALLING
    if (gDTMF_ReplyState != DTMF_REPLY_NONE)
        RADIO_PrepareCssTX();
#endif

    if (PreviousFunction == FUNCTION_TRANSMIT) {
        ST7565_FixInterfGlitch();
        gVFO_RSSI_bar_level[0] = 0;
        gVFO_RSSI_bar_level[1] = 0;
    } else if (PreviousFunction != FUNCTION_RECEIVE) {
        return;
    }

#if defined(ENABLE_FMRADIO)
    if (gFmRadioMode)
        gFM_RestoreCountdown_10ms = fm_restore_countdown_10ms;
#endif

#ifdef ENABLE_DTMF_CALLING
    if (gDTMF_CallState == DTMF_CALL_STATE_CALL_OUT ||
        gDTMF_CallState == DTMF_CALL_STATE_RECEIVED ||
        gDTMF_CallState == DTMF_CALL_STATE_RECEIVED_STAY) {
        gDTMF_auto_reset_time_500ms = gEeprom.DTMF_auto_reset_time * 2;
    }
#endif
    gUpdateStatus = true;
}

void FUNCTION_PowerSave() {
#ifdef ENABLE_FEAT_F4HWN_SLEEP
    if (gWakeUp) {
        gPowerSave_10ms = gEeprom.BATTERY_SAVE * 200; // deep sleep now indexed on BatSav
    } else {
        gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10;
    }
#else
    gPowerSave_10ms = gEeprom.BATTERY_SAVE * 10;
#endif
    gPowerSaveCountdownExpired = false;

    gRxIdleMode = true;

    gMonitor = false;

    BK4819_DisableVox();
    BK4819_Sleep();

    BK4819_ToggleGpioOut(BK4819_GPIO0_PIN28_RX_ENABLE, false);

    gUpdateStatus = true;

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

#define SSTV_MULT 1

#define SCALE_FREQ(freq) ((((uint32_t)(freq) * 1353245u) + (1u << 16)) >> 17)

void BK4819_PlaySSTV_Robot8() {


    BK4819_EnterTxMute();
    BK4819_SetAF(gEeprom.DTMF_SIDE_TONE);
    BK4819_TransmitTone(true, 1000);
    SYSTEM_DelayMs(100);
    BK4819_WriteRegister(BK4819_REG_70,
                         BK4819_REG_70_MASK_ENABLE_TONE1 | (66u << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
    BK4819_EnableTXLink();

    SYSTEM_DelayMs(50);
    // **Send 9x Vertical Sync Pulses (1,900 Hz, 50ms each)**

    // **Send 3x Vertical Sync Pulses (1,900 Hz, 30ms each)**
    for (int i = 0; i < 3; i++) {
        BK4819_WriteRegister(BK4819_REG_71, SCALE_FREQ(1900));
        SYSTEM_DelayMs(30);
    }

    // **Transmit Image Data**
    for (uint8_t y = 0; y < 8; y++) {
        for (uint8_t rep = 0; rep < 2; rep++) {
            BK4819_WriteRegister(BK4819_REG_71, SCALE_FREQ(1200));
            SYSTEM_DelayMs(5);
            for (uint8_t bit = 0; bit < 8; bit++) {
                for (uint8_t x = 0; x < 128; x++) {
                    uint8_t byte = gFrameBuffer[y][x];
                    uint8_t bitV = byte & (1 << bit);
                    uint16_t freq = (bitV) ? 2300 : 1200;
                    BK4819_WriteRegister(BK4819_REG_71, SCALE_FREQ(freq));
                    SYSTICK_DelayUs(432);  // Pixel time = ~0.432ms
                }
            }
        }
    }

    BK4819_WriteRegister(BK4819_REG_70, 0x0000);
    // **End Transmission: Mute Transmitter**
    BK4819_ExitTxMute();
}

void FUNCTION_Transmit() {
    // if DTMF is enabled when TX'ing, it changes the TX audio filtering !! .. 1of11

    MSG_EnableRX(false);

    BK4819_DisableDTMF();

#ifdef ENABLE_DTMF_CALLING
    // clear the DTMF RX buffer
    DTMF_clear_RX();
#endif

    // clear the DTMF RX live decoder buffer
    gDTMF_RX_live_timeout = 0;
    memset(gDTMF_RX_live, 0, sizeof(gDTMF_RX_live));

#if defined(ENABLE_FMRADIO)
    if (gFmRadioMode)
        BK1080_Init0();
#endif

#ifdef ENABLE_ALARM
    if (gAlarmState == ALARM_STATE_SITE_ALARM) {
        GUI_DisplayScreen();

        AUDIO_AudioPathOff();

        SYSTEM_DelayMs(20);
        BK4819_PlayTone(500, 0);
        SYSTEM_DelayMs(2);

        AUDIO_AudioPathOn();

        gEnableSpeaker = true;

        SYSTEM_DelayMs(60);
        BK4819_ExitTxMute();

        gAlarmToneCounter = 0;
        return;
    }
#endif

    gUpdateStatus = true;

    GUI_DisplayScreen();

    RADIO_SetTxParameters();

    // turn the RED LED on
    BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true);

    DTMF_Reply();

    BK4819_SetScramble(gCurrentVfo->SCRAMBLING_TYPE);
    if (gCurrentVfo->DTMF_PTT_ID_TX_MODE == PTT_ID_APOLLO)
        BK4819_PlaySingleTone(2525, 250, 0, gEeprom.DTMF_SIDE_TONE);

#if defined(ENABLE_ALARM) || defined(ENABLE_TX1750)
    if (gAlarmState != ALARM_STATE_OFF) {
#ifdef ENABLE_TX1750
        if (gAlarmState == ALARM_STATE_TX1750) {
            BK4819_TransmitTone(gEeprom.DTMF_SIDE_TONE, 1750);
            gAlarmState = ALARM_STATE_OFF;
        }
#endif

        if (gAlarmState == ALARM_STATE_SSTV) {
            BK4819_PlaySSTV_Robot8();
            gAlarmState = ALARM_STATE_OFF;
        }
#ifdef ENABLE_ALARM
        if (gAlarmState == ALARM_STATE_TXALARM)
            BK4819_TransmitTone(true, 500);

        gAlarmToneCounter = 0;
#endif

        SYSTEM_DelayMs(2);
        AUDIO_AudioPathOn();
        gEnableSpeaker = true;
        BK4819_ExitTxMute();

        gVfoConfigureMode = VFO_CONFIGURE;
        return;
    }
#endif



    if (gSetting_backlight_on_tx_rx & BACKLIGHT_ON_TR_TX) {
        BACKLIGHT_TurnOn();
    }
}


void FUNCTION_Select(FUNCTION_Type_t Function) {
    const FUNCTION_Type_t PreviousFunction = gCurrentFunction;
    const bool bWasPowerSave = PreviousFunction == FUNCTION_POWER_SAVE;

    gCurrentFunction = Function;

    if (bWasPowerSave && Function != FUNCTION_POWER_SAVE) {
        BK4819_Conditional_RX_TurnOn_and_GPIO6_Enable();
        gRxIdleMode = false;
        UI_DisplayStatus();
    }

    /*
    switch (Function) {
        case FUNCTION_FOREGROUND:
            FUNCTION_Foreground(PreviousFunction);
            return;

        case FUNCTION_POWER_SAVE:
            FUNCTION_PowerSave();
            return;

        case FUNCTION_TRANSMIT:
            FUNCTION_Transmit();
            break;

        case FUNCTION_MONITOR:
            gMonitor = true;
            break;

        case FUNCTION_INCOMING:
        case FUNCTION_RECEIVE:
        case FUNCTION_BAND_SCOPE:
        default:
            break;
    }
    */

    if (Function == FUNCTION_FOREGROUND) {
        FUNCTION_Foreground(PreviousFunction);
        return;
    }

    if (Function == FUNCTION_POWER_SAVE) {
        FUNCTION_PowerSave();
        return;
    }

    if (Function == FUNCTION_TRANSMIT) {
        FUNCTION_Transmit();
    } else if (Function == FUNCTION_MONITOR) {
        gMonitor = true;
    }

    gBatterySaveCountdown_10ms = battery_save_count_10ms;
    gSchedulePowerSave = false;

#if defined(ENABLE_FMRADIO)
    if (Function != FUNCTION_INCOMING)
        gFM_RestoreCountdown_10ms = 0;
#endif
}