#include "snmp_helper.h"
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <string.h>
#include <stdio.h>
#include <pthread.h>

static pthread_once_t init_once = PTHREAD_ONCE_INIT;

static void init_snmp_once(void) {
    // Initialize the SNMP library
    init_snmp("towerops-agent");

    // Configure to output numeric OIDs only (no MIB names)
    // This ensures OIDs are in format "1.3.6.1.2.1.1.1.0" not "SNMPv2-MIB::sysDescr.0"
    netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,
                       NETSNMP_OID_OUTPUT_NUMERIC);
}

int snmp_init_library(void) {
    pthread_once(&init_once, init_snmp_once);
    return 0;
}

void* snmp_open_session(
    const char* ip_address,
    uint16_t port,
    const char* community,
    int version,
    int64_t timeout_us,
    int retries,
    const snmp_v3_config_t* v3_config,
    char* error_buf,
    size_t error_buf_len
) {
    struct snmp_session session, *sess_handle;

    // Ensure library is initialized
    snmp_init_library();

    // Initialize session structure
    snmp_sess_init(&session);

    // Set peer address with port (e.g., "192.168.1.1:161")
    // This is the modern way - remote_port field is deprecated
    char peername[256];
    snprintf(peername, sizeof(peername), "%s:%u", ip_address, port);
    session.peername = strdup(peername);
    if (!session.peername) {
        if (error_buf && error_buf_len > 0) {
            snprintf(error_buf, error_buf_len, "Failed to allocate memory for peer address");
        }
        return NULL;
    }

    // Set SNMP version
    switch (version) {
        case 1:
            session.version = SNMP_VERSION_1;
            break;
        case 2:
            session.version = SNMP_VERSION_2c;
            break;
        case 3:
            session.version = SNMP_VERSION_3;
            break;
        default:
            free(session.peername);
            if (error_buf && error_buf_len > 0) {
                snprintf(error_buf, error_buf_len, "Unsupported SNMP version: %d", version);
            }
            return NULL;
    }

    // Configure version-specific parameters
    if (version == 3) {
        // SNMPv3 configuration
        if (!v3_config || !v3_config->username) {
            free(session.peername);
            if (error_buf && error_buf_len > 0) {
                snprintf(error_buf, error_buf_len, "SNMPv3 requires username");
            }
            return NULL;
        }

        // Set security name (username)
        session.securityName = strdup(v3_config->username);
        session.securityNameLen = strlen(v3_config->username);

        // Set security level
        if (v3_config->security_level) {
            if (strcmp(v3_config->security_level, "authPriv") == 0) {
                session.securityLevel = SNMP_SEC_LEVEL_AUTHPRIV;
            } else if (strcmp(v3_config->security_level, "authNoPriv") == 0) {
                session.securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;
            } else {
                session.securityLevel = SNMP_SEC_LEVEL_NOAUTH;
            }
        } else {
            session.securityLevel = SNMP_SEC_LEVEL_NOAUTH;
        }

        // Set authentication protocol and password
        if (session.securityLevel >= SNMP_SEC_LEVEL_AUTHNOPRIV) {
            if (v3_config->auth_password) {
                session.securityAuthProto = usmHMACMD5AuthProtocol;
                session.securityAuthProtoLen = USM_AUTH_PROTO_MD5_LEN;

                if (v3_config->auth_protocol) {
                    if (strcmp(v3_config->auth_protocol, "SHA") == 0) {
                        session.securityAuthProto = usmHMACSHA1AuthProtocol;
                        session.securityAuthProtoLen = USM_AUTH_PROTO_SHA_LEN;
                    }
                }

                session.securityAuthKeyLen = USM_AUTH_KU_LEN;
                if (generate_Ku(session.securityAuthProto,
                               session.securityAuthProtoLen,
                               (u_char*)v3_config->auth_password,
                               strlen(v3_config->auth_password),
                               session.securityAuthKey,
                               &session.securityAuthKeyLen) != SNMPERR_SUCCESS) {
                    free(session.peername);
                    free((void*)session.securityName);
                    if (error_buf && error_buf_len > 0) {
                        snprintf(error_buf, error_buf_len, "Failed to generate auth key");
                    }
                    return NULL;
                }
            }
        }

        // Set privacy protocol and password
        if (session.securityLevel >= SNMP_SEC_LEVEL_AUTHPRIV) {
            if (v3_config->priv_password) {
                session.securityPrivProto = usmDESPrivProtocol;
                session.securityPrivProtoLen = USM_PRIV_PROTO_DES_LEN;

                if (v3_config->priv_protocol) {
                    if (strcmp(v3_config->priv_protocol, "AES") == 0) {
                        session.securityPrivProto = usmAESPrivProtocol;
                        session.securityPrivProtoLen = USM_PRIV_PROTO_AES_LEN;
                    }
                }

                session.securityPrivKeyLen = USM_PRIV_KU_LEN;
                if (generate_Ku(session.securityAuthProto,
                               session.securityAuthProtoLen,
                               (u_char*)v3_config->priv_password,
                               strlen(v3_config->priv_password),
                               session.securityPrivKey,
                               &session.securityPrivKeyLen) != SNMPERR_SUCCESS) {
                    free(session.peername);
                    free((void*)session.securityName);
                    if (error_buf && error_buf_len > 0) {
                        snprintf(error_buf, error_buf_len, "Failed to generate priv key");
                    }
                    return NULL;
                }
            }
        }
    } else {
        // v1/v2c: Set community string
        if (community && community[0]) {
            session.community = (u_char*)strdup(community);
            if (!session.community) {
                free(session.peername);
                if (error_buf && error_buf_len > 0) {
                    snprintf(error_buf, error_buf_len, "Failed to allocate memory for community string");
                }
                return NULL;
            }
            session.community_len = strlen(community);
        }
    }

    // Set timeout and retries
    session.timeout = timeout_us;
    session.retries = retries;

    // Open the session
    sess_handle = snmp_sess_open(&session);

    // Clean up temporary allocations
    free(session.peername);
    if (session.community) {
        // Zero out community string before freeing
        memset((void*)session.community, 0, session.community_len);
        free((void*)session.community);
    }
    if (session.securityName) {
        free((void*)session.securityName);
    }

    // Check for errors
    if (!sess_handle) {
        if (error_buf && error_buf_len > 0) {
            // Get error message from library
            int liberr, syserr;
            char *errstr;
            snmp_error(&session, &liberr, &syserr, &errstr);
            snprintf(error_buf, error_buf_len, "%s", errstr);
            free(errstr);
        }
        return NULL;
    }

    return sess_handle;
}

void snmp_close_session(void* sess_handle) {
    if (sess_handle) {
        snmp_sess_close(sess_handle);
    }
}

int snmp_get(
    void* sess_handle,
    const char* oid_str,
    void* value_buf,
    size_t value_buf_len,
    int* value_type,
    char* error_buf,
    size_t error_buf_len
) {
    if (!sess_handle || !oid_str || !value_buf || !value_type) {
        if (error_buf && error_buf_len > 0) {
            snprintf(error_buf, error_buf_len, "Invalid parameters");
        }
        return -1;
    }

    oid anOID[MAX_OID_LEN];
    size_t anOID_len = MAX_OID_LEN;

    // Parse OID string
    if (!read_objid(oid_str, anOID, &anOID_len)) {
        if (error_buf && error_buf_len > 0) {
            snprintf(error_buf, error_buf_len, "Failed to parse OID: %s", oid_str);
        }
        return -1;
    }

    // Create GET PDU
    struct snmp_pdu *pdu = snmp_pdu_create(SNMP_MSG_GET);
    if (!pdu) {
        if (error_buf && error_buf_len > 0) {
            snprintf(error_buf, error_buf_len, "Failed to create PDU");
        }
        return -1;
    }

    // Add OID to PDU
    snmp_add_null_var(pdu, anOID, anOID_len);

    // Send request
    struct snmp_pdu *response = NULL;
    int status = snmp_sess_synch_response(sess_handle, pdu, &response);

    if (status != STAT_SUCCESS || !response) {
        if (error_buf && error_buf_len > 0) {
            if (status == STAT_TIMEOUT) {
                snprintf(error_buf, error_buf_len, "Request timeout");
            } else {
                snprintf(error_buf, error_buf_len, "Request failed");
            }
        }
        if (response) {
            snmp_free_pdu(response);
        }
        return -1;
    }

    // Extract value from response
    int result = -1;
    if (response->variables) {
        struct variable_list *var = response->variables;
        *value_type = var->type;

        switch (var->type) {
            case ASN_OCTET_STR:
            case ASN_OPAQUE:
            case ASN_IPADDRESS:
                if (var->val_len <= value_buf_len) {
                    memcpy(value_buf, var->val.string, var->val_len);
                    result = (int)var->val_len;
                } else {
                    if (error_buf && error_buf_len > 0) {
                        snprintf(error_buf, error_buf_len, "Buffer too small");
                    }
                }
                break;

            case ASN_INTEGER:
            case ASN_COUNTER:
            case ASN_GAUGE:
            case ASN_TIMETICKS:
            case ASN_UINTEGER:
                if (sizeof(long) <= value_buf_len) {
                    *((long*)value_buf) = *var->val.integer;
                    result = sizeof(long);
                }
                break;

            case ASN_COUNTER64:
                if (sizeof(struct counter64) <= value_buf_len) {
                    memcpy(value_buf, var->val.counter64, sizeof(struct counter64));
                    result = sizeof(struct counter64);
                }
                break;

            case ASN_OBJECT_ID:
                // Convert OID to string representation
                {
                    char oid_buf[256];
                    snprint_objid(oid_buf, sizeof(oid_buf), var->val.objid, var->val_len / sizeof(oid));
                    size_t oid_str_len = strlen(oid_buf);
                    if (oid_str_len <= value_buf_len) {
                        memcpy(value_buf, oid_buf, oid_str_len);
                        result = (int)oid_str_len;
                    } else {
                        if (error_buf && error_buf_len > 0) {
                            snprintf(error_buf, error_buf_len, "Buffer too small for OID string");
                        }
                    }
                }
                break;

            case ASN_NULL:
                // NULL values are valid but contain no data
                result = 0;
                break;

            default:
                // Unknown type
                if (error_buf && error_buf_len > 0) {
                    snprintf(error_buf, error_buf_len, "Unsupported type: %d", var->type);
                }
                break;
        }
    }

    snmp_free_pdu(response);
    return result;
}

int snmp_walk(
    void* sess_handle,
    const char* oid_str,
    snmp_walk_result_t* results,
    size_t max_results,
    size_t* num_results,
    char* error_buf,
    size_t error_buf_len
) {
    if (!sess_handle || !oid_str || !results || !num_results) {
        if (error_buf && error_buf_len > 0) {
            snprintf(error_buf, error_buf_len, "Invalid parameters");
        }
        return -1;
    }

    oid root[MAX_OID_LEN];
    size_t rootlen = MAX_OID_LEN;

    // Parse starting OID
    if (!read_objid(oid_str, root, &rootlen)) {
        if (error_buf && error_buf_len > 0) {
            snprintf(error_buf, error_buf_len, "Failed to parse OID: %s", oid_str);
        }
        return -1;
    }

    oid name[MAX_OID_LEN];
    size_t name_length = rootlen;
    memcpy(name, root, rootlen * sizeof(oid));

    *num_results = 0;
    int running = 1;

    while (running && *num_results < max_results) {
        // Create GETNEXT PDU
        struct snmp_pdu *pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
        if (!pdu) {
            break;
        }

        snmp_add_null_var(pdu, name, name_length);

        // Send request
        struct snmp_pdu *response = NULL;
        int status = snmp_sess_synch_response(sess_handle, pdu, &response);

        if (status != STAT_SUCCESS || !response || !response->variables) {
            if (response) {
                snmp_free_pdu(response);
            }
            break;
        }

        struct variable_list *var = response->variables;

        // Check if we've walked past the root OID
        if (var->name_length < rootlen ||
            snmp_oid_ncompare(var->name, var->name_length, root, rootlen, rootlen) != 0) {
            snmp_free_pdu(response);
            break;
        }

        // Store result
        snmp_walk_result_t *res = &results[*num_results];

        // Convert OID to string
        snprint_objid(res->oid, sizeof(res->oid), var->name, var->name_length);

        // Store value
        res->value_type = var->type;
        res->value_len = 0;

        switch (var->type) {
            case ASN_OCTET_STR:
            case ASN_OPAQUE:
            case ASN_IPADDRESS:
                if (var->val_len <= sizeof(res->value)) {
                    memcpy(res->value, var->val.string, var->val_len);
                    res->value_len = var->val_len;
                }
                break;

            case ASN_OBJECT_ID:
                // Convert OID to string representation
                {
                    char oid_buf[256];
                    snprint_objid(oid_buf, sizeof(oid_buf), var->val.objid, var->val_len / sizeof(oid));
                    size_t oid_str_len = strlen(oid_buf);
                    if (oid_str_len < sizeof(res->value)) {
                        memcpy(res->value, oid_buf, oid_str_len);
                        res->value_len = oid_str_len;
                    }
                }
                break;

            case ASN_INTEGER:
            case ASN_COUNTER:
            case ASN_GAUGE:
            case ASN_TIMETICKS:
            case ASN_UINTEGER:
                if (sizeof(long) <= sizeof(res->value)) {
                    *((long*)res->value) = *var->val.integer;
                    res->value_len = sizeof(long);
                }
                break;

            case ASN_COUNTER64:
                if (sizeof(struct counter64) <= sizeof(res->value)) {
                    memcpy(res->value, var->val.counter64, sizeof(struct counter64));
                    res->value_len = sizeof(struct counter64);
                }
                break;
        }

        if (res->value_len > 0) {
            (*num_results)++;
        }

        // Update OID for next iteration
        if (var->name_length <= MAX_OID_LEN) {
            memcpy(name, var->name, var->name_length * sizeof(oid));
            name_length = var->name_length;
        } else {
            running = 0;
        }

        snmp_free_pdu(response);
    }

    return 0;
}