#include "ngspice/ngspice.h"
#include "ngspice/iferrmsg.h"

#include "ngspice/evt.h"
#include "ngspice/evtproto.h"


static void Evt_Node_destroy(Evt_Node_Info_t *info, Evt_Node_t *node);
static void Evt_Node_Data_destroy(Evt_Ckt_Data_t *evt, Evt_Node_Data_t *node_data);
static void Evt_Msg_Data_destroy(Evt_Ckt_Data_t *evt, Evt_Msg_Data_t *msg_data);
static void Evt_Queue_destroy(Evt_Ckt_Data_t *evt, Evt_Queue_t *queue);
static void Evt_State_Data_destroy(Evt_Ckt_Data_t *evt, Evt_State_Data_t *state_data);
static void Evt_Data_destroy(Evt_Ckt_Data_t *evt, Evt_Data_t *data);
static void Evt_Job_destroy(Evt_Job_t *job);
static void Evt_Info_destroy(Evt_Info_t *info);


int
EVTdest(Evt_Ckt_Data_t *evt)
{
    /* Exit immediately if no event-driven instances in circuit */
    if (evt->counts.num_insts == 0)
        return OK;

    Evt_Queue_destroy(evt, & evt->queue);
    Evt_Data_destroy(evt, & evt->data);
    Evt_Job_destroy(& evt->jobs);
    Evt_Info_destroy(& evt->info);

    return OK;
}


static void
Evt_Queue_destroy(Evt_Ckt_Data_t *evt, Evt_Queue_t *queue)
{
    Evt_Output_Queue_t  *output_queue = &(queue->output);
    Evt_Node_Queue_t    *node_queue = &(queue->node);
    Evt_Inst_Queue_t    *inst_queue = &(queue->inst);

    int i;

    /* instance queue */
    for (i = 0; i < evt->counts.num_insts; i++) {
        Evt_Inst_Event_t *event = inst_queue->head[i];
        while (event) {
            Evt_Inst_Event_t *next = event->next;
            tfree(event);
            event = next;
        }
    }
    tfree(inst_queue->head);
    tfree(inst_queue->current);
    tfree(inst_queue->last_step);
    tfree(inst_queue->free);

    tfree(inst_queue->modified_index);
    tfree(inst_queue->modified);
    tfree(inst_queue->pending_index);
    tfree(inst_queue->pending);
    tfree(inst_queue->to_call_index);
    tfree(inst_queue->to_call);

    /* node queue */

    tfree(node_queue->to_eval_index);
    tfree(node_queue->to_eval);
    tfree(node_queue->changed_index);
    tfree(node_queue->changed);

    /* output queue */
    for (i = 0; i < evt->counts.num_outputs; i++) {
        Evt_Output_Event_t *event;
        event = output_queue->head[i];
        while (event) {
            Evt_Output_Event_t *next = event->next;
            tfree(event->value);
            tfree(event);
            event = next;
        }
        event = output_queue->free[i];
        while (event) {
            Evt_Output_Event_t *next = event->next;
            tfree(event->value);
            tfree(event);
            event = next;
        }
    }
    tfree(output_queue->head);
    tfree(output_queue->current);
    tfree(output_queue->last_step);
    tfree(output_queue->free);

    tfree(output_queue->modified_index);
    tfree(output_queue->modified);
    tfree(output_queue->pending_index);
    tfree(output_queue->pending);
    tfree(output_queue->changed_index);
    tfree(output_queue->changed);
}


static void
Evt_Data_destroy(Evt_Ckt_Data_t *evt, Evt_Data_t *data)
{
    Evt_State_Data_destroy(evt, data->state);
    Evt_Node_Data_destroy(evt, data->node);
    Evt_Msg_Data_destroy(evt, data->msg);

    tfree(data->node);
    tfree(data->state);
    tfree(data->msg);
    tfree(data->statistics);
}


static void
Evt_State_Data_destroy(Evt_Ckt_Data_t *evt, Evt_State_Data_t *state_data)
{
    int i;

    if (!state_data)
        return;

    for (i = 0; i < evt->counts.num_insts; i++) {
        Evt_State_t *state = state_data->head[i];
        while (state) {
            Evt_State_t *next = state->next;
            tfree(state->block);
            tfree(state);
            state = next;
        }
    }

    tfree(state_data->head);
    tfree(state_data->tail);
    tfree(state_data->last_step);
    tfree(state_data->free);

    tfree(state_data->modified);
    tfree(state_data->modified_index);
    tfree(state_data->total_size);

    for (i = 0; i < evt->counts.num_insts; i++) {
        Evt_State_Desc_t *p = state_data->desc[i];
        while (p) {
            Evt_State_Desc_t *next_p = p->next;
            tfree(p);
            p = next_p;
        }
    }

    tfree(state_data->desc);
}


static void
Evt_Node_Data_destroy(Evt_Ckt_Data_t *evt, Evt_Node_Data_t *node_data)
{
    int i;

    if (!node_data)
        return;

    for (i = 0; i < evt->counts.num_nodes; i++) {
        Evt_Node_Info_t *info = evt->info.node_table[i];
        Evt_Node_t *node;
        node = node_data->head[i];
        while (node) {
            Evt_Node_t *next = node->next;
            Evt_Node_destroy(info, node);
            tfree(node);
            node = next;
        }
        node = node_data->free[i];
        while (node) {
            Evt_Node_t *next = node->next;
            Evt_Node_destroy(info, node);
            tfree(node);
            node = next;
        }
    }
    tfree(node_data->head);
    tfree(node_data->tail);
    tfree(node_data->last_step);
    tfree(node_data->free);

    tfree(node_data->modified);
    tfree(node_data->modified_index);

    for (i = 0; i < evt->counts.num_nodes; i++) {
        Evt_Node_Info_t *info = evt->info.node_table[i];
        Evt_Node_destroy(info, &(node_data->rhs[i]));
        Evt_Node_destroy(info, &(node_data->rhsold[i]));
    }

    tfree(node_data->rhs);
    tfree(node_data->rhsold);
    tfree(node_data->total_load);
}


static void
Evt_Node_destroy(Evt_Node_Info_t *info, Evt_Node_t *node)
{
    tfree(node->node_value);
    tfree(node->inverted_value);

    if (node->output_value) {
        int k = info->num_outputs;
        while (--k >= 0)
            tfree(node->output_value[k]);
        tfree(node->output_value);
    }
}


static void
Evt_Msg_Data_destroy(Evt_Ckt_Data_t *evt, Evt_Msg_Data_t *msg_data)
{
    int i;

    if (!msg_data)
        return;

    for (i = 0; i < evt->counts.num_ports; i++) {
        Evt_Msg_t *msg;
        msg = msg_data->head[i];
        while (msg) {
            Evt_Msg_t *next = msg->next;
            if (msg->text)
                tfree(msg->text);
            tfree(msg);
            msg = next;
        }
        msg = msg_data->free[i];
        while (msg) {
            Evt_Msg_t *next = msg->next;
            if (msg->text)
                tfree(msg->text);
            tfree(msg);
            msg = next;
        }
    }

    tfree(msg_data->head);
    tfree(msg_data->tail);
    tfree(msg_data->last_step);
    tfree(msg_data->free);

    tfree(msg_data->modified);
    tfree(msg_data->modified_index);
}


static void
Evt_Job_destroy(Evt_Job_t *job)
{
    int i;

    for (i = 0; i < job->num_jobs; i++)
        tfree(job->job_name[i]);

    tfree(job->job_name);
    tfree(job->node_data);
    tfree(job->state_data);
    tfree(job->msg_data);
    tfree(job->statistics);
}


static void
Evt_Info_destroy(Evt_Info_t *info)
{
    Evt_Inst_Info_t *inst = info->inst_list;
    while (inst) {
        Evt_Inst_Info_t *next_inst = inst->next;
        tfree(inst);
        inst = next_inst;
    }
    tfree(info->inst_table);

    Evt_Node_Info_t *nodei = info->node_list;
    while (nodei) {
        Evt_Node_Info_t *next_nodei = nodei->next;
        tfree(nodei->name);

        Evt_Inst_Index_t *p = nodei->inst_list;
        while (p) {
            Evt_Inst_Index_t *next_p = p->next;
            tfree(p);
            p = next_p;
        }

        tfree(nodei);
        nodei = next_nodei;
    }
    tfree(info->node_table);

    Evt_Port_Info_t *port = info->port_list;
    while (port) {
        Evt_Port_Info_t *next_port = port->next;
        tfree(port->node_name);
        tfree(port->inst_name);
        tfree(port->conn_name);
        tfree(port);
        port = next_port;
    }
    tfree(info->port_table);

    Evt_Output_Info_t *output = info->output_list;
    while (output) {
        Evt_Output_Info_t *next_output = output->next;
        tfree(output);
        output = next_output;
    }
    tfree(info->output_table);

    tfree(info->hybrid_index);
}
