/* Synthetic-only SDK/RTOS boundaries. No device, network or captured speech. */
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdatomic.h>
#include <string.h>
#include <stdarg.h>
static void host_log(const char *fmt, ...) {(void)fmt;}
#define LOGI(...) host_log(__VA_ARGS__)
#define ESP_LOGI(tag,...) host_log(__VA_ARGS__)
#define pdFALSE 0
#define eInvalid 0
#define eDeleted 1
#define ESP_PLATFORM 1
typedef unsigned UBaseType_t;
typedef struct {unsigned number, priority, base; int core;} host_task_t;
typedef host_task_t *TaskHandle_t;
typedef struct {unsigned xTaskNumber,uxBasePriority;int eCurrentState;} TaskStatus_t;
static host_task_t rtc_task={42,4,4,1}, conv_task={43,5,5,1};
static bool rtc_present=true, conv_present;
static bool engine_ready=true, publish_fail;
static const char *current_name="VolcRTCMain";
static unsigned priority_writes, start_events, tts_sends, audio_sends, creates;
static bool authorized=true, rtc_mode=true, create_fail;
static int tts_result;
static TaskHandle_t xTaskGetHandle(const char *name) {
    if(!strcmp(name,"VolcRTCMain")) return rtc_present?&rtc_task:NULL;
    if(!strcmp(name,"conv_ai")) return conv_present?&conv_task:NULL;
    assert(0);return NULL;
}
static void vTaskGetInfo(TaskHandle_t task,TaskStatus_t *s,int a,int b) {assert(!task);(void)a;(void)b;s->xTaskNumber=rtc_task.number;s->uxBasePriority=rtc_task.base;s->eCurrentState=eInvalid;}
static unsigned uxTaskPriorityGet(TaskHandle_t task) {assert(!task);return rtc_task.priority;}
static void vTaskPrioritySet(TaskHandle_t task,unsigned priority) {
    assert(!task);
    bool inherited=rtc_task.priority>rtc_task.base;
    rtc_task.base=priority;
    if(!inherited || rtc_task.priority<priority) rtc_task.priority=priority;
    priority_writes++;
}
static int xTaskGetCoreID(TaskHandle_t task) {assert(!task);return rtc_task.core;}
static TaskHandle_t xTaskGetCurrentTaskHandle(void) {return &rtc_task;}
static const char *pcTaskGetName(TaskHandle_t task) {assert(!task);return current_name;}
static uint64_t esp_timer_get_time(void) {return 987654321;}
enum {VOLC_SERVICE_AI_CONVERSATION=1,VOLC_SERVICE_AI_CONVERSATION_START,VOLC_SERVICE_AI_CONVERSATION_INTERRUPT,
      VOLC_SERVICE_AI_CONVERSATION_QUIT,VOLC_SERVICE_AI_CONVERSATION_OVER,VOLC_SERVICE_AI_CONVERSATION_TOGGLE};
static int aios_event_pub(int event,void *a,void *b) {assert(event==VOLC_SERVICE_AI_CONVERSATION);assert(!a&&!b);start_events++;return publish_fail?-1:0;}
static bool call_client_is_engine_ready(void) {return engine_ready;}
bool conv_ai_service_diagnostic_active(void);
typedef void *volc_hal_capture_t;
typedef struct {int data_type;} volc_hal_frame_info_t;
typedef struct {bool commit;int data_type;} volc_audio_frame_info_t;
enum {VOLC_AUDIO_DATA_TYPE_PCM=11,VOLC_AGENT_TYPE_TTS=12};
static struct {void *engine;int wait_time;} conv_service={(void*)1,0};
static atomic_bool is_stop,stop_requested;
static bool platform_conversation_audio_authorized(void) {return authorized;}
bool platform_runtime_rtc(void) {return rtc_mode;}
static uint64_t host_now_ms=1234;
static uint64_t volc_osal_get_time_ms(void) {return host_now_ms;}
typedef struct {int type;} esp_gmf_afe_evt_t;
enum {ESP_GMF_AFE_EVT_VAD_START=1,ESP_GMF_AFE_EVT_VAD_END};
static int get_rssi(void) {return -10;}
static int volc_send_audio_data(void *engine,const void *data,int len,volc_audio_frame_info_t *info) {
    assert(engine==conv_service.engine&&data&&len>0&&!info->commit);audio_sends++;return 0;
}
static int volc_send_text_to_agent(void *engine,const char *text,int type,int interrupt) {
    assert(engine==conv_service.engine&&type==VOLC_AGENT_TYPE_TTS&&interrupt==1);
    assert(strstr(text,"这是连续语音播放测试。")&&strstr(text,"平稳地读完。"));tts_sends++;return tts_result;
}
typedef int aios_ret_t;
typedef struct {int id;} aios_event_t;
typedef struct {void *conv_thread_id;} volc_conv_service_manager_t;
typedef struct {void *display_handle;} volc_hal_context_t;
typedef void *volc_hal_display_t;
static volc_hal_context_t hal_context={NULL};
static volc_hal_context_t *volc_get_global_hal_context(void) {return &hal_context;}
enum {AIOS_Ret_NotHandled,AIOS_Ret_Handled,VOLC_DISPLAY_OBJ_STATUS,VOLC_DISPLAY_TEXT};
typedef struct {char name[32];int stack_size,priority,stack_in_ext;} volc_osal_thread_param_t;
static void volc_hal_display_set_content(void *h,int obj,int kind,const char *text) {(void)h;(void)obj;(void)kind;(void)text;}
static void diagnostic_prepare(void);
static void conv_ai_service_prepare_task(void) {diagnostic_prepare();}
static void conv_ai_service_task(void *arg) {(void)arg;}
void conv_ai_service_diagnostic_reset(void);
static void volc_osal_thread_destroy(void *handle) {(void)handle;}
static void vTaskDeleteWithCaps(TaskHandle_t handle) {assert(handle==&conv_task);conv_present=false;}
static void conv_ai_service_task_stop(void) {conv_ai_service_diagnostic_reset();}
static int volc_osal_thread_create(void **handle,volc_osal_thread_param_t *p,void (*f)(void*),void *arg) {
    (void)p;(void)f;(void)arg;creates++;if(create_fail)return -1;*handle=&conv_task;conv_present=true;return 0;
}
/* @PRODUCTION@ */
static void capture(void) {
    int16_t pcm[8]={1,2,3,4,5,6,7,8};volc_hal_frame_info_t info={VOLC_AUDIO_DATA_TYPE_PCM};
    __audio_capture_cb(NULL,pcm,sizeof(pcm),&info);
}
int main(void) {
    // Execute the real VAD + PCM callback: silence does not postpone idle,
    // continuous detected speech does, and its end starts a fresh minute.
    is_stop=false;stop_requested=false;call_idle_activity();
    host_now_ms+=59000;capture();assert(!call_idle_expired());
    host_now_ms+=1000;capture();assert(call_idle_expired());
    esp_gmf_afe_evt_t vad={ESP_GMF_AFE_EVT_VAD_START};
    call_idle_capture_event(&vad,NULL);
    for(int tick=0;tick<180;tick++){host_now_ms+=1000;capture();assert(!call_idle_expired());}
    vad.type=ESP_GMF_AFE_EVT_VAD_END;call_idle_capture_event(&vad,NULL);
    host_now_ms+=60000;capture();assert(call_idle_expired());
    audio_sends=0;
    rtc_task.priority=rtc_task.base=3;
    current_name="worker";__rtc_diagnostic_priority_apply();assert(priority_writes==0&&rtc_task.base==3);
    diagnostic_rtc_priority(false);diagnostic_rtc_priority(true);assert(priority_writes==0);
    current_name="VolcRTCMain";__rtc_diagnostic_priority_apply();
    assert(rtc_task.priority==6&&rtc_task.base==6&&priority_writes==1&&!conv_ai_service_diagnostic_active());
    unsigned writes=priority_writes;__rtc_diagnostic_priority_apply();assert(priority_writes==writes);
    rtc_task.priority=rtc_task.base=7;__rtc_diagnostic_priority_apply();assert(rtc_task.base==7&&priority_writes==writes);
    rtc_task.priority=8;rtc_task.base=3; // inherited effective priority is not the configured base
    __rtc_diagnostic_priority_apply();assert(rtc_task.base==6&&rtc_task.priority==8);
    rtc_task.priority=rtc_task.base;__rtc_diagnostic_priority_apply();assert(rtc_task.priority==6);
    rtc_task.number++;rtc_task.priority=rtc_task.base=3; // a new same-name task must receive the floor too
    __rtc_diagnostic_priority_apply();assert(rtc_task.base==6);
    rtc_task.priority=rtc_task.base=4;__rtc_diagnostic_priority_apply();assert(rtc_task.base==6);
    writes=priority_writes;diagnostic_rtc_priority(false);diagnostic_rtc_priority(true);
    conv_ai_service_diagnostic_reset();diagnostic_close();diagnostic_prepare();
    __rtc_diagnostic_priority_apply();assert(rtc_task.base==6&&priority_writes==writes);
    volc_rtc_diagnostic_snapshot();assert(atomic_load(&diagnostic_rtc_seen));
    assert(atomic_load(&diagnostic_rtc_base)==6&&priority_writes==writes);
    puts("PASS normal-call self-only floor, higher base, inherited effective priority, new task, no diagnostic override");

    capture();assert(audio_sends==1);
    conv_ai_service_diagnostic_tts();assert(start_events==1&&diagnostic_uplink_suppressed());
    capture();assert(audio_sends==1);
    assert(diagnostic_take_pending()==DIAGNOSTIC_TTS&&diagnostic_uplink_suppressed());
    diagnostic_send_tts();assert(tts_sends==1&&diagnostic_uplink_suppressed());
    conv_present=true;conv_ai_service_diagnostic_tts();assert(start_events==1);
    assert(diagnostic_take_pending()==DIAGNOSTIC_TTS);diagnostic_send_tts();assert(tts_sends==2);
    assert(diagnostic_take_pending()==DIAGNOSTIC_NONE);capture();assert(audio_sends==1);
    conv_ai_service_diagnostic_say();assert(start_events==1&&!diagnostic_uplink_suppressed());
    assert(diagnostic_take_pending()==DIAGNOSTIC_SAY);capture();assert(audio_sends==2);
    conv_ai_service_diagnostic_tts();diagnostic_rtc_priority(true);conv_ai_service_diagnostic_reset();__rtc_diagnostic_priority_apply();
    assert(diagnostic_take_pending()==DIAGNOSTIC_NONE&&!diagnostic_uplink_suppressed()&&rtc_task.priority==6);
    capture();assert(audio_sends==3);
    puts("PASS fixed TTS bypass, same-room repetition, mic-only gate, say/reset restores uplink");

    conv_ai_service_diagnostic_tts();tts_result=-1;diagnostic_send_tts();assert(!diagnostic_uplink_suppressed());
    assert(diagnostic_take_pending()==DIAGNOSTIC_NONE);
    rtc_mode=false;conv_ai_service_diagnostic_tts();unsigned sends=tts_sends;diagnostic_send_tts();
    assert(tts_sends==sends&&!diagnostic_uplink_suppressed());rtc_mode=true;tts_result=0;
    conv_present=false;create_fail=true;volc_conv_service_manager_t manager={0};
    aios_event_t event={VOLC_SERVICE_AI_CONVERSATION_START};
    conv_ai_service_diagnostic_tts();diagnostic_rtc_priority(true);
    assert(__state_conversation(&manager,&event)==AIOS_Ret_Handled&&creates==1&&!manager.conv_thread_id);
    assert(!diagnostic_uplink_suppressed()&&diagnostic_take_pending()==DIAGNOSTIC_NONE&&rtc_task.priority==6);
    authorized=false;capture();assert(audio_sends==3);
    puts("PASS send failure, unsupported transport and actual task-create failure restore diagnostics");
    conv_present=true;conv_ai_service_diagnostic_tts();diagnostic_close();
    conv_ai_service_diagnostic_tts();assert(!diagnostic_uplink_suppressed()&&!conv_ai_service_diagnostic_active());
    assert(diagnostic_take_pending()==DIAGNOSTIC_NONE);
    diagnostic_rtc_priority(true);assert(rtc_task.priority==6);
    conv_ai_service_diagnostic_reset();conv_ai_service_diagnostic_tts(); // reset must preserve closing gate
    assert(!diagnostic_uplink_suppressed());
    conv_present=false;publish_fail=true;conv_ai_service_diagnostic_tts();
    assert(!diagnostic_uplink_suppressed()&&!conv_ai_service_diagnostic_active());publish_fail=false;
    conv_ai_service_diagnostic_tts();assert(diagnostic_uplink_suppressed());diagnostic_prepare();
    assert(diagnostic_take_pending()==DIAGNOSTIC_TTS);diagnostic_close();diagnostic_prepare();
    assert(!diagnostic_uplink_suppressed()&&!conv_ai_service_diagnostic_active());
    puts("PASS closing request rejection, no priority pollution, event failure and next-call reset");
    puts("voice diagnostic host PASS");return 0;
}