/*
 * SPDX-FileCopyrightText: 2022 Unisoc (Shanghai) Technologies Co., Ltd.
 *
 * SPDX-License-Identifier: LicenseRef-Unisoc-General-1.0
 */

#include <string.h>
#include <errno.h>
#include "callback.h"
#include "gnss_adapter.h"

extern bool vdbg;

extern int gps_status;
extern int agps_status;
extern int ni_notification_id;

void srv_gps_location_callback(GpsLocation* location)
{

    if (location && (location->flags & GPS_LOCATION_HAS_LAT_LONG)) {
        char location_buf[LOCATION_BUF_SIZE];
        memset(location_buf, '\0', sizeof(location_buf));
        sprintf(location_buf, "%s%llu^%f^%f^", TAG_LOCATION_NAME, location->timestamp, location->latitude, location->longitude);

        int write_num = -1;
        if (vdbg) ALOGD("%s, %s", __func__, location_buf);
        //report location to tty
        if ((write_num= write(mpty, location_buf, LOCATION_BUF_SIZE)) < 0) {
            ALOGE("write to mpty %d ERROR: %s, ret=%d\n", mpty, strerror(errno), write_num);
        } else {
            if (vdbg) ALOGI("write to mpty %d success, ret=%d\n", mpty, write_num);
        }
    }

}

void srv_gps_status_callback(GpsStatus* status)
{
    if(!status)
    {
        ALOGE("%s input is null", __func__);
        return;
    } else {
        ALOGD("%s: GpsStatus->status=%d", __func__, status->status);
        gps_status = status->status;

        int type_array[] = { DBUS_TYPE_INT32 };
        dh_sendsignal(DBUS_BUS_SYSTEM, GNSS_ADAPTER_BUS_SIGNAL_PATH,
            GNSS_ADAPTER_BUS_SIGNAL_INTERFACE,
            SIGNAL_NAME_GPS_STATUS_CHANGED,
            type_array, 1, status->status);
    }
}

void srv_gps_sv_status_callback(GpsSvStatus* sv_info)
{
    // do nothing
    ALOGI("%s ", __func__);
}

void srv_gnss_sv_status_callback(GnssSvStatus* sv_info)
{
    if(sv_info != NULL)
    {

        char svstatus_buf[SVSTATUS_BUF_SIZE];
        char tmp_str[32];
        memset(svstatus_buf, '\0', sizeof(svstatus_buf));
        memset(tmp_str, '\0', sizeof(tmp_str));
        sprintf(svstatus_buf, "%s", TAG_SVSTATUS_NAME);
        for (int i = 0; i < sv_info->num_svs; i++) {
            memset(tmp_str, 0, sizeof(tmp_str));
            if(i == sv_info->num_svs -1)
                sprintf(tmp_str, "%d^%f", sv_info->gnss_sv_list[i].svid, sv_info->gnss_sv_list[i].c_n0_dbhz);
            else
                sprintf(tmp_str, "%d^%f^", sv_info->gnss_sv_list[i].svid, sv_info->gnss_sv_list[i].c_n0_dbhz);
            strcat(svstatus_buf, tmp_str);
        }

        int write_num = -1;
        ALOGD("%s, %s", __func__, svstatus_buf);
        //report location to tty
        if ((write_num= write(mpty, svstatus_buf, SVSTATUS_BUF_SIZE)) < 0) {
            ALOGE("write to mpty %d ERROR: %s, ret=%d\n", mpty, strerror(errno), write_num);
        }else{
            ALOGD("write to mpty %d success, ret=%d\n", mpty, write_num);
        }
    }
}
void srv_gps_nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
{
    int write_num = -1;
    //just output
    if (vdbg) ALOGI("nmea=%s timestamp=%lld length=%d", nmea, timestamp, length);
    if(nmea != NULL )
    {
        //send location to Framework
        if ((write_num= write(mpty, nmea, length + 1)) < 0) {
            ALOGE("write to mtpy %d ERROR: %s, ret=%d\n", mpty, strerror(errno), write_num);
        } else {
            if (vdbg) ALOGD("write to mpty %d success, ret=%d\n", mpty, write_num);
        }
    }
}
void srv_gps_set_capabilities(uint32_t capabilities)
{
    //do nothing
    ALOGD("%s set capabilities is 0x%x", __func__, capabilities);
}
void srv_gps_acquire_wakelock()
{
    // do nothing
    ALOGI("%s ", __func__);
}
void srv_gps_release_wakelock()
{
    // do nothing
    ALOGI("%s ", __func__);
}
void srv_gps_request_utc_time()
{
    // do nothing
    ALOGI("%s ", __func__);
}
void srv_gnss_set_system_info(const GnssSystemInfo* info)
{
     // do nothing
    ALOGI("%s %x", __func__, info->year_of_hw);
}

void srv_agps_status_callback(AGpsStatus* status)
{
    if(!status)
    {
        ALOGE("%s input is null", __func__);
        return;
    } else {
        ALOGD("%s: AgpsStatus->size=%zu", __func__, status->size);
        ALOGD("%s: AgpsStatus->type=%d", __func__, status->type);
        ALOGD("%s: AgpsStatus->status=%d", __func__, status->status);
        ALOGD("%s: AgpsStatus->ipaddr=%d", __func__, status->ipaddr);
        agps_status = status->status;

        int type_array[] = { DBUS_TYPE_INT32, DBUS_TYPE_INT32, DBUS_TYPE_INT32 };
        dh_sendsignal(DBUS_BUS_SYSTEM, GNSS_ADAPTER_BUS_SIGNAL_PATH,
            GNSS_ADAPTER_BUS_SIGNAL_INTERFACE,
            SIGNAL_NAME_AGPS_STATUS_CHANGED,
            type_array, 3, status->type, status->status, status->ipaddr);
    }

    if (status->status & GPS_REQUEST_AGPS_DATA_CONN)
    {
        //shall  active the SUPL  APN and  then inform the libgps ,here  just inform the libgps
        fetch_agps_connection();
    }
    else if(status->status & GPS_RELEASE_AGPS_DATA_CONN)
    {
        drop_agps_connection();
    }
}

    /*FOR NI notify callback */
void srv_gps_ni_notify_callback(GpsNiNotification *notification)
{
    if (!notification) {
        ALOGE("%s: GpsNiNotification is null", __func__);
        return;
    }
    ALOGD("%s: notification id is %d", __func__, notification->notification_id);
    ALOGD("%s: notification ni type is %d", __func__, notification->ni_type);
    ALOGD("%s: notification flags is %d", __func__, notification->notify_flags);
    ALOGD("%s: notification timeout is %d", __func__, notification->timeout);
    ALOGD("%s: notification requestor id is %s", __func__, notification->requestor_id);
    ALOGD("%s: notification text is %s", __func__, notification->text);
    int type_array[] = {
            DBUS_TYPE_INT32,
            DBUS_TYPE_INT32,
            DBUS_TYPE_INT32,
            DBUS_TYPE_INT32,
            DBUS_TYPE_STRING,
            DBUS_TYPE_STRING
    };

    dh_sendsignal(DBUS_BUS_SYSTEM, GNSS_ADAPTER_BUS_SIGNAL_PATH,
            GNSS_ADAPTER_BUS_SIGNAL_INTERFACE,
            SIGNAL_NAME_NI_NOTIFICATION,
            type_array, 6,
            notification->notification_id,
            notification->ni_type,
            notification->notify_flags,
            notification->timeout,
            notification->requestor_id,
            notification->text);
}

    /*FOR RIL callback*/
void srv_agps_ril_request_set_id(uint32_t flags)
{
    int rlt = feed_agps_sim_info(flags);
    if(rlt == -1){
        ALOGE("%s failed!",__func__);
    }else{
        ALOGD("%s success!",__func__);
    }
}

void srv_agps_ril_request_ref_loc(uint32_t flags)
{
    int rlt = 0;
    rlt = feed_agps_cell_info(flags);
    if(rlt == -1){
        ALOGE("%s failed!",__func__);
    }else{
        ALOGD("%s success!",__func__);
    }
}
    /*FOR  GPS geofence callback*/
    // todo
    /*FOR gnss MSR correction callback*/
void srv_gnss_set_capabilities_callback(int capabilities)
{
    //do nothing
    ALOGD("%s set GNSS  capabilities is 0x%x", __func__, capabilities);
}
    /*FOR  gps MSR callback*/
void  srv_gps_measurement_callback(GpsData* data)
{
    // shall inform Framework
    //
    ALOGI("%s ", __func__);
}
void srv_gnss_measurement_callback(GnssData* data)
{
    // shall inform Framework
    //
    ALOGI("%s ", __func__);
}
    /* FOR visibility callback */
void srv_gnss_nfw_notify_callback(GnssNfwNotification* notification)
{
     // do nothing
    //
    ALOGI("%s ", __func__);
}
bool srv_isInEmergencySession_callback()
{
     // do nothing
    //
    ALOGI("%s ", __func__);
    return  false;
}

    /*FOR  navigation message callback*/
void srv_gps_navigation_message_callback(GpsNavigationMessage* message)
{
     // shall inform Framework
    //
    ALOGI("%s ", __func__);
}
void srv_gnss_navigation_message_callback(GnssNavigationMessage* message)
{
     // shall inform Framework
    //
    ALOGI("%s ", __func__);
}


pthread_t srv_gps_create_thread(const char* name, void (*start)(void *), void* arg)
{
    int ret = 0;
    pthread_t threadId = 0;
    pthread_attr_t attr;

    pthread_attr_init(&attr);

    ret = pthread_create(&threadId, &attr, (void *(*)(void *))start, arg);
    if(ret != 0)
    {
        return -1;
    }
    pthread_detach(threadId);

    return threadId;
}
GpsCallbacks g_gpsCallback =
{
    sizeof(GpsCallbacks),
    srv_gps_location_callback,
    srv_gps_status_callback,
    srv_gps_sv_status_callback,
    srv_gps_nmea_callback,
    srv_gps_set_capabilities,
    srv_gps_acquire_wakelock,
    srv_gps_release_wakelock,
    srv_gps_create_thread,
    srv_gps_request_utc_time,
    srv_gnss_set_system_info,
    srv_gnss_sv_status_callback
};

AGpsCallbacks g_agpsCallback =
{
    srv_agps_status_callback,
    srv_gps_create_thread
};

GpsNiCallbacks g_niCallback =
{
    srv_gps_ni_notify_callback,
    srv_gps_create_thread
};

AGpsRilCallbacks g_rilCallback =
{
    srv_agps_ril_request_set_id,
    srv_agps_ril_request_ref_loc,
    srv_gps_create_thread
};

GpsMeasurementCallbacks  g_msrCallback =
{
    sizeof(GpsMeasurementCallbacks),
    srv_gps_measurement_callback,
    srv_gnss_measurement_callback
};

GpsNavigationMessageCallbacks g_navCallback =
{
    sizeof(GpsNavigationMessageCallbacks),
    srv_gps_navigation_message_callback,
    srv_gnss_navigation_message_callback
};

GnssMeasurementCorrectionCallbacks g_msrCorrCallback =
{
    sizeof(GnssMeasurementCorrectionCallbacks),
    srv_gnss_set_capabilities_callback
};

GnssVisibilityControlCallbacks g_visCtrlCallback =
{
    sizeof(GnssVisibilityControlCallbacks),
    srv_gnss_nfw_notify_callback,
    srv_isInEmergencySession_callback
};