/*
 * Copyright (c) 2015 Wind River Systems, Inc.
*
* SPDX-License-Identifier: Apache-2.0
*
 */

/**
 * @file
 * Wind River CGTS Platform Host Base Class Member Implementation.
 */

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>
#include <errno.h>  /* for ENODEV, EFAULT and ENXIO */
#include <unistd.h> /* for close and usleep */

using namespace std;

#ifdef  __AREA__
#undef  __AREA__
#define __AREA__ "~~~"
#endif

#include "nodeBase.h"
#include "hostClass.h"
#include "nodeUtil.h"


hostBaseClass::hostBaseClass() /* constructor */
{
    for(unsigned int i = 0; i < MAX_HOSTS; ++i)
    {
        host_ptrs[i] = NULL;
    }
    bm_provisioned= false;
    head = tail   = NULL;
    memory_allocs = 0   ;
    memory_used   = 0   ;
    hosts         = 0   ;
    service       = 0   ;
   
    /* Start with null identity */
    my_hostname.clear() ;
    my_local_ip.clear() ;
    my_float_ip.clear() ;
}

hostBaseClass::~hostBaseClass() /* destructor */
{
    host *      ptr = head ;
    host * temp_ptr = ptr  ;
    while ( ptr != NULL )
    {
        temp_ptr = ptr ;
        ptr = ptr->next ;
        delHost (temp_ptr);
    }
    if ( memory_used != 0 )
    {
       elog ( "Apparent Memory Leak - Allocs:%d and Bytes:%d\n", 
           memory_allocs, memory_used );
    }
    else
    {
        dlog ( "No Memory Leaks\n\n");
    }   
}

/*
 * Allocates memory for a new host and stores its the address in host_ptrs 
 *
 * @param void
 * @return pointer to the newly allocted host memory
 */ 
struct hostBaseClass::host * hostBaseClass::newHost ( void )
{
   struct hostBaseClass::host * host_ptr = NULL ;
      
   if ( memory_allocs == 0 )
   {
       memset ( host_ptrs, 0 , sizeof(struct host *)*MAX_HOSTS);
   }

   // find an empty spot
   for ( int i = 0 ; i < MAX_HOSTS ; i++ )
   {
      if ( host_ptrs[i] == NULL )
      {
          host_ptrs[i] = host_ptr = new host ;
          memory_allocs++ ;
          memory_used += sizeof (struct hostBaseClass::host);
          // ilog ("%p:%p - mem after new: allocs:%d used:%d\n", host_ptr , host_ptrs[i], memory_allocs, memory_used);
          return host_ptr ;
      }
   }
   elog ( "Failed to save new host pointer address\n" );
   return host_ptr ;
}


/* Frees the memory of a pre-allocated host and removes
 * it from the host_ptrs list 
 * @param host * pointer to the host memory address to be freed
 * @return int return code { PASS or -EINVAL }
 */
int hostBaseClass::delHost ( struct hostBaseClass::host * host_ptr )
{
    if ( memory_allocs > 0 )
    {
        for ( int i = 0 ; i < MAX_NODES ; i++ )
        {
            if ( host_ptrs[i] == host_ptr )
            {
                // ilog ("%p:%p - mem before del: allocs:%d used:%d\n", host_ptr , host_ptrs[i], memory_allocs, memory_used);
                delete host_ptr ;
                host_ptrs[i] = NULL ;
                memory_allocs-- ;
                memory_used -= sizeof (struct hostBaseClass::host);
                return PASS ;
            }
        }
        elog ( "Error: Unable to validate memory address being freed\n" );
    }
    else
       elog ( "Error: Free memory called when there is no memory to free\n" );
    
    return -EINVAL ;
}

 /*
  * Allocate new host and tack it on the end of the host_list
  */  
struct 
hostBaseClass::host* hostBaseClass::addHost( string hostname )
{
    /* verify host is not already provisioned */
    struct host * ptr = getHost ( hostname );
    if ( ptr )
    {
        if ( remHost ( hostname ) )
        {
            /* Should never get here but if we do then */
            /* something is seriously wrong */
            elog ("Error: Unable to remove host during reprovision\n"); 
            return static_cast<struct host *>(NULL);
        }
    }
    
    /* allocate memory for new host */
    ptr = newHost ();
    if( ptr == NULL )
    {
        elog ( "Error: Failed to allocate memory for new host\n" );
		return static_cast<struct host *>(NULL);
    }
    
    /* Init the new host */
    ptr->hostname = hostname ;

    /* If the host list is empty add it to the head */
    if( head == NULL )
    {
        head = ptr ;  
        tail = ptr ;
        ptr->prev = NULL ;
        ptr->next = NULL ;
    }
    else
    {
        /* link the new_host to the tail of the host_list
         * then mark the next field as the end of the host_list
         * adjust tail to point to the last host
         */
        tail->next = ptr  ;
        ptr->prev  = tail ;
        ptr->next  = NULL ;
        tail = ptr ; 
    }

    hosts++ ;

    return ptr ;
}

struct hostBaseClass::host* hostBaseClass::getHost ( string hostname )
{
   /* check for empty list condition */
   if ( head == NULL )
      return NULL ;

   for ( struct host * ptr = head ;  ; ptr = ptr->next )
   {
       if ( !hostname.compare ( ptr->hostname ))
       {
           // ilog ("%s %p\n", hostname.c_str(), ptr );
           return ptr ;  
       }
       else if ( !hostname.compare ( ptr->uuid ))
       {
           // ilog ("%s %p\n", hostname.c_str(), ptr );
           return ptr ;  
       }
       if (( ptr->next == NULL ) || ( ptr == tail ))
           break ;
    }
    return static_cast<struct host *>(NULL);
}

/* Remove a hist from the linked list of hosts - may require splice action */
int hostBaseClass::remHost( string hostname )
{
    if ( hostname.c_str() == NULL )
        return -ENODEV ;

    if ( head == NULL )
        return -ENXIO ;
    
    struct host * ptr = getHost ( hostname );

    if ( ptr == NULL )
        return -EFAULT ;

    /* If the host is the head host */
    if ( ptr == head )
    {
        /* only one host in the list case */
        if ( head == tail )
        {
            dlog ("Single Host -> Head Case\n");
            head = NULL ;
            tail = NULL ;
        }
        else
        {
            dlog ("Multiple Hosts -> Head Case\n");
            head = head->next ;
            head->prev = NULL ; 
        }
    }
    /* if not head but tail then there must be more than one
     * host in the list so go ahead and chop the tail.
     */
    else if ( ptr == tail )
    {
        dlog ("Multiple Host -> Tail Case\n");
        tail = tail->prev ;
        tail->next = NULL ;
    }
    else
    {
        dlog ("Multiple Host -> Full Splice Out\n");
        ptr->prev->next = ptr->next ;
        ptr->next->prev = ptr->prev ;
    }
    delHost ( ptr );
    hosts-- ;
    return (PASS) ;
}



/******************************************************************************************
 ******************************************************************************************
 *****************************************************************************************/ 



int hostBaseClass::add_host ( node_inv_type & inv )
{
    int rc = FAIL ;
    struct hostBaseClass::host * host_ptr = static_cast<struct host *>(NULL);

    if  (( inv.name.empty())           || 
         ( !inv.name.compare ("none")) ||
         ( !inv.name.compare ("None")))
    {
        wlog ("Refusing to add host with 'null' or 'invalid' hostname (%s)\n", 
               inv.uuid.c_str());
        return (FAIL_INVALID_HOSTNAME) ;
    }

    host_ptr = hostBaseClass::getHost(inv.name);
    if ( host_ptr ) 
    {
        dlog ("%s Already provisioned\n", host_ptr->hostname.c_str());

        /* Send back a retry in case the add needs to be converted to a modify */
        return (RETRY);
    }
    /* Otherwise add it as a new host */
    else
    {
        if ( daemon_get_cfg_ptr()->debug_level > 1 )
            print_inv ( inv );

        host_ptr = hostBaseClass::addHost(inv.name);
        if ( host_ptr )
        {
            host_ptr->ip   = inv.ip   ;
            host_ptr->mac  = inv.mac  ;
            host_ptr->uuid = inv.uuid ;

            host_ptr->type = inv.type ;
            host_ptr->nodetype = CGTS_NODE_NULL ;
            
            host_ptr->retries = 0 ;
            host_ptr->toggle = false ;

            /* Add to the end of inventory */
            hostlist.push_back ( host_ptr->hostname );
            dlog ("%s Added Host Base\n", inv.name.c_str());
            rc = PASS ;
        }
        else
        {
            elog ("%s Host Base Add Failed\n", inv.name.c_str());
            rc = FAIL_NULL_POINTER ;
        }
    }
    return (rc);
}

int hostBaseClass::rem_host ( string hostname )
{
    int rc = FAIL ;
    if ( ! hostname.empty() )
    {  
        hostlist.remove ( hostname );
        rc = hostBaseClass::remHost ( hostname );
    }
    return ( rc );
}

int hostBaseClass::del_host ( string hostname )
{
    int rc = FAIL_DEL_UNKNOWN ;
    hostBaseClass::host * host_ptr = hostBaseClass::getHost( hostname );
    if ( host_ptr ) 
    {
        rc = rem_host ( host_ptr->hostname );
        if ( rc == PASS )
        {
            dlog ("%s Deleted\n", host_ptr->hostname.c_str());
            print_node_info();
        }
        else
        {
            elog ("%s Delete Failed (rc:%d)\n", hostname.c_str(), rc );
        }
    }
    else
    {
        wlog ("Unknown hostname: %s\n", hostname.c_str());
    }
    return (rc);
}

/** Get this hosts uuid address */
string hostBaseClass::get_uuid ( string hostname )
{
    hostBaseClass::host * host_ptr ;
    host_ptr = hostBaseClass::getHost ( hostname );
    if ( host_ptr != NULL )
    {
         return (host_ptr->uuid );
    }
    elog ("%s uuid lookup failed\n", hostname.c_str() );
    return ("");
}

/** Get this hosts uuid address */
string hostBaseClass::get_hostname ( string uuid )
{
    hostBaseClass::host * host_ptr ;
    host_ptr = hostBaseClass::getHost ( uuid );
    if ( host_ptr != NULL )
    {
         return (host_ptr->hostname );
    }
    elog ("%s hostname lookup failed\n", uuid.c_str() );
    return ("");
}

/** Get this hosts ip address */
string hostBaseClass::get_ip ( string hostname )
{
    hostBaseClass::host * host_ptr ;
    host_ptr = hostBaseClass::getHost ( hostname );
    if ( host_ptr != NULL )
    {
         return (host_ptr->ip );
    }
    elog ("%s ip lookup failed\n", hostname.c_str() );
    return ("");
}

static string null_str = "" ;
string hostBaseClass::get_hostaddr ( string hostname )
{
    hostBaseClass::host* host_ptr ;
    host_ptr = hostBaseClass::getHost ( hostname );
    if ( host_ptr != NULL )
    {
        return ( host_ptr->ip );
    }
    return ( null_str );
}



void hostBaseClass::print_node_info ( void )
{
    fflush (stdout);
    fflush (stderr);
}

void hostBaseClass::memLogDelimit ( void )
{
    char str[MAX_MEM_LOG_DATA] ;
    snprintf (&str[0], MAX_MEM_LOG_DATA, "-------------------------------------------------------------\n");
    mem_log (str);
}

void hostBaseClass::mem_log_host ( struct hostBaseClass::host * host_ptr )
{
    char str[MAX_MEM_LOG_DATA] ;
    snprintf (&str[0], MAX_MEM_LOG_DATA, "%s\t%s - %s - %s - %s\n", 
               host_ptr->hostname.c_str(), 
               host_ptr->ip.c_str(),
               host_ptr->mac.c_str(),
               host_ptr->uuid.c_str(), 
               host_ptr->type.c_str());
    mem_log (str);
}

void hostBaseClass::memDumpNodeState ( string hostname )
{
    hostBaseClass::host* host_ptr ;
    host_ptr = hostBaseClass::getHost ( hostname );
    if ( host_ptr == NULL )
    {
        mem_log ( hostname, ": ", "Not Found hostBaseClass\n" );
        return ;
    }
    else
    {
        mem_log_host ( host_ptr );
        // memLogDelimit ();
    }
}