###############################
# 
# @(#)HP Operations Smart Plug-ins for Infrastructure 11.14.014 06/07/14
#
###############################
package oasampleutils;
#require Exporter;
use vars       qw($VERSION @ISA @EXPORT);
use POSIX;
#use Config;
use warnings;
use Data::Dumper;

# set the version for version checking
$VERSION     = 0.01;
@ISA         = qw(Exporter);

sub GetDataDir {
        open (OVPATHEXE, "ovpath -datadir|") or die("unable to run ovpath binary: \n");
        my $out = <OVPATHEXE>;
        close OVPATHEXE;
        chomp $out;
        $out = $out . '/';
        return $out;
}

sub GetInstDir {
        open (OVPATHEXE, "ovpath -instdir|") or die("unable to run ovpath binary: \n");
        my $out = <OVPATHEXE>;
        close OVPATHEXE;
        chomp $out;
        $out = $out . '/';
        return $out;
}

BEGIN
{
        unshift(@INC, GetInstDir."/nonOV/perl/a/lib/site_perl/5.8.8/i686-linux-thread-multi/");
}

use oaperlapi;

sub new
{
        my $class = shift;
        my $self = {};

        $self->{Domain} = shift;
        $self->{Class} = shift;
        $self->{Filter}={};
        $self->{Idl} = undef;
        $self->{MC}  = undef;
	
		$self->{Policy_interval} = undef;
		$self->{accessclient} = undef;
		$self->{InstanceCount} = undef;
		$self->{InstaceFilter} = ();
        bless ($self, $class);
        
        return $self;
}
sub setinterval
{
	my $self = shift;
	$self->{Policy_interval} = shift;
}

sub setinstancecount
{
	my $self = shift;
	$self->{InstanceCount} = shift;
}
sub getmetricvalues()
{
	
	my $self 			= shift;
	my $MetricArrRef 	= shift;
	my $option 			= "last";
    $option = shift if @_;
	
	my $MCFdn = oaperlapi::ManagedClassFdn->new();
	 my $MC = oaperlapi::ManagedClassIdentifier->new();

	my $dgc = oaperlapi::DataGlossaryAndChapter->new();
	my $dqr =  oaperlapi::DataQueryRequest->new();
	my $dqrc =  oaperlapi::DataQueryRequestForAClass->new();
	my $accessClient = oaperlapi::OAAccess->new();
	my @MetricArr 	= @$MetricArrRef;
	
	my %metric_hash;
		
	if (scalar @{ $self->{InstaceFilter}})
	{
		SetInstanceFilterInDqrcByFdn($dqrc,$self->{InstaceFilter});
	}
	else
	{	
		if (!$self->{Idl})
       		{
                	my @attrib = ();
                	$self->GetInstanceDetails(\@attrib);
        	}
		my $idl = $self->{Idl};
        	$accessClient = $self->{accessclient};
       	 	$MC = $self->{MC};
		SetInstanceFilterInDqrc($idl,$dqrc);
	}
	
	my $metric_count = scalar (@MetricArr) ;
			
	my @Metric_Values = ();
	
	for(my $j = 0 ; $j < $metric_count ; $j++ )
	{		
		$dqrc->AddMetricFilter(oaperlapi::String_t->new($MetricArr[$j]));
	}

	my %stored_filter = %{$self->{Filter}};
	if (!scalar (keys (%stored_filter)))
	{
		$dqrc->SetFetchAllInstancesFlag(1);
	}
	
	$MC->SetName( oaperlapi::String_t->new($self->{Class}));
	$MC->SetDomain(oaperlapi::String_t->new($self->{Domain}));
    	$MCFdn->AddContainedManagedClass($MC);

	$dqrc->SetManagedClass($MCFdn);

	#$dqrc->SetIdMode(0);
	$dqr->AddDataQueryRequestForAClass($dqrc);

	my $time_now = time();
	my $start_time ;
	if(!$self->{InstanceCount})
	{
		$start_time = $time_now - $self->{Policy_interval}* 3 * 60;
	}
	else
	{
		 $start_time = $time_now - $self->{Policy_interval}* $self->{InstanceCount} * 60;
		 $option = "Not Valid";
	}
	$dqr->SetStartTime($start_time);
	$dqr->SetEndTime($time_now);
	$dqr->SetSumInterval($self->{Policy_interval} * 60 );
	
	$dqr->SetPiggyBackChapterSize(10000);

	$accessClient->FetchDataGlossaryAndChapter($dqr, $dgc);
	my $dg = $dgc->GetDataGlossary();
	my $dc = $dgc->GetDataChapter();
	my $num_pages = $dc->GetDataChapterListSize();
	my $pg_idx = 0;
	if ($option eq "last")
	{
		$pg_idx  = ($num_pages > 0) ? ($num_pages - 1) :  0;		
	}
	my $Num_Construct_Count ;
	if($self->{Class} eq "Cluster")
	{
		$Num_Construct_Count = 0;
	}
	else
	{
		$Num_Construct_Count = 1;
	}
    for(my $k=$pg_idx; $k<$num_pages; $k++)
	{
		my $dp = $dc->GetDataPageAt($k);
		my $num_classes = $dp->GetDataPageListSize();
		my $dp4c;
		my $dg4c;
		my $classid;
		my $num_instances;
		for(my $l=0; $l<$num_classes; $l++)
		{
			my $dp4c = $dp->GetDataPageForAClassAt($l);
			my $dg4c = $dg->GetDataGlossaryForAClassAt($l);
			my $classid = $dg4c->GetManagedClassId();
			my $num_instances = $dg4c->GetInstanceListSize();
			my $num_metrics = $dg4c->GetMetricListSize();

			for(my $m = 0; $m < $num_instances; $m++)
			{
				my $Key;
				my $Value;
				my $instDetails;
				my $inst;
								
				my $instid 			= $dg4c->GetInstanceIdAt($m);
				my $inst_fdn 			= $dg4c->GetInstanceFdnAt($m);

				$inst 				= $inst_fdn->GetInstanceAt($inst_fdn->GetInstanceChainLength() - 1);
				my $inst_fdn_str 		= oaperlapi::MBS_t->new($inst_fdn->GetInstanceFdnString())->ToCharPtr();				
				my $Hostname 			= oaperlapi::MBS_t->new($inst_fdn->GetInstanceAt(0)->GetInstanceConstructAt($Num_Construct_Count)->GetValue()->GetValueAsString())->ToCharPtr();
							
				##Get Metric
				for(my $p = 0 ; $p < $metric_count ; $p++ )
				{
					my $tmp_val = oaperlapi::MBS_t->new($dp4c->GetValueAt($m, $p)->GetValueAsString())->ToCharPtr();
					if ( lc($tmp_val) eq "na" or $tmp_val eq "-"  or $tmp_val  eq "" )
					{
						$tmp_val = "NA";
					}
					$Metric_Values[$p] = $tmp_val; 					
					push (@{$metric_hash{$Hostname}},$Metric_Values[$p]);
				}							
			}
		}
	}
	return \%metric_hash ; 	
}

sub getattribvalues()
{	
	my $self = shift;
	my $AttribArrRef = shift;
	my $ret = $self->GetInstanceDetails($AttribArrRef);
	my $idl = $self->{Idl};
	
	my @AttribArr = @$AttribArrRef;	
	my %attrib_hash;
	
	my $num_idl4c = $idl->GetNumInstanceDetailsListForAClass();
	
	my $Num_Construct_Count ;
	if($self->{Class} eq "Cluster")
	{
		$Num_Construct_Count = 0;
	}
	else
	{
		$Num_Construct_Count = 1;
	}
	
	for(my $i=0; $i<$num_idl4c; $i++)
	{
		my $idl4c = $idl->GetInstanceDetailsListForAClassAt($i);
		my $MBS_McFdn_str = oaperlapi::MBS_t->new($idl4c->GetManagedClassFdn()->GetManagedClassFdnString());

		my $num_inst = $idl4c->GetNumInstanceDetails();
		for(my $j=0; $j<$num_inst; $j++)
		{
			my $instDetails = $idl4c->GetInstanceDetailsAt($j);
			my $instFdn = $instDetails->GetInstanceFdn();
			my $inst = $instFdn->GetInstanceAt($instFdn->GetInstanceChainLength() - 1);
			my $num_attrib = $inst->GetNumAttributes();
			
			my $Hostname = oaperlapi::MBS_t->new($instFdn->GetInstanceAt(0)->GetInstanceConstructAt($Num_Construct_Count)->GetValue()->GetValueAsString())->ToCharPtr();
			
			my $MIVP;
			my $metVal;
			my $metid;

  			foreach my $inattr (@AttribArr) {
							
				for(my $attrib_cnt = 0 ; $attrib_cnt < $num_attrib;$attrib_cnt++)
				{
					$MIVP = $inst->GetAttributeAt($attrib_cnt);
					$metid =$MIVP->GetMetricIdentifier();
					my $str_metid = oaperlapi::MBS_t->new($metid->GetName())->ToCharPtr();
					
					if($str_metid eq $inattr)
					{					
						$metVal =oaperlapi::MBS_t->new($MIVP->GetValue()->GetValueAsString())->ToCharPtr();	
						if ( lc($metVal) eq "na" or $metVal eq "-"  or $metVal  eq "" )
						{
							$metVal = "NA";
						}		
						push (@{$attrib_hash{$Hostname}},$metVal);	
					}					
				}					
			}
		}
	}
	return \%attrib_hash ; 
}

sub processattributes 
{
        my $self = shift;
        my $AttribArrRef = shift;
        my $idl = shift;
        
        my @AttribArr = @$AttribArrRef;

        my %attrib_hash;
        my $num_idl4c = $idl->GetNumInstanceDetailsListForAClass();

        for(my $i=0; $i<$num_idl4c; $i++)
        {
                my $idl4c = $idl->GetInstanceDetailsListForAClassAt($i);
                my $MBS_McFdn_str = oaperlapi::MBS_t->new($idl4c->GetManagedClassFdn()->GetManagedClassFdnString());

                my $num_inst = $idl4c->GetNumInstanceDetails();
                for(my $j=0; $j<$num_inst; $j++)
                {
                        my $instDetails = $idl4c->GetInstanceDetailsAt($j);
                        my $instFdn = $instDetails->GetInstanceFdn();
                        my $inst = $instFdn->GetInstanceAt($instFdn->GetInstanceChainLength() - 1);
                        my $num_attrib = $inst->GetNumAttributes();

                        my $Hostname = oaperlapi::MBS_t->new($instFdn->GetInstanceAt(0)->GetInstanceConstructAt(1)->GetValue()->GetValueAsString())->ToCharPtr();

                        my $MIVP;
                        my $metVal;
                        my $metid;
                        for(my $attrib_cnt = 0 ; $attrib_cnt < $num_attrib;$attrib_cnt++)
                        {
                                $MIVP = $inst->GetAttributeAt($attrib_cnt);
                                $metid =$MIVP->GetMetricIdentifier();
                                $metVal =oaperlapi::MBS_t->new($MIVP->GetValue()->GetValueAsString())->ToCharPtr();
                                push (@{$attrib_hash{$Hostname}},$metVal);
                        }
                }
        }
        return \%attrib_hash ;
}

sub getassociations()
{
	#Node->Ds or Ds->Node,Host->Ds , Ds->Cluster etc.retrun asso hash
	my $self = shift;
	my ( $fromclass,$toclass) = @_;	
	my @attrib = ();
	my $Domain;
	my $Class;
	my $Ret ;
	$self->GetInstanceDetails(\@attrib);
	
	if ($toclass eq "DS")
	{		
		$Domain = "Virtualization";
		$Class  = "DSNodeRelation";
		$Ret = $self->GetDsAssociations($Domain,$Class);
		return $Ret;
	}
	elsif ($toclass eq "Node")
	{		
		$Domain = "Virtualization";
                $Class  = "NodeDSRelation";
		$Ret = $self->GetDsAssociations($Domain,$Class);
		return $Ret;
	}
	else
	{
		print "This association NOT supported yet\n";
	}
	return $Ret;
}

sub setinstancefilter()
{
	my $self = shift;
	my $InstanceArrRef = shift;	
	$self->{InstaceFilter} = $InstanceArrRef;
}

sub getinstances()
{
        my $self = shift;
        my @attrib = ();
        $self->GetInstanceDetails(\@attrib);
        my $idl = $self->{Idl};        
        my $InstnceRef = $self->GetInstanceList($idl);        
        return $InstnceRef;
}

sub getevents()
{
	my $self 			= shift;   
	my %event_hash = ();
    	
	my $accessClient = oaperlapi::OAAccess->new();	
	my $mqr = oaperlapi::ModelQueryRequest->new();	
	my $model = oaperlapi::MetricModel->new();	
	
	my $dgc = oaperlapi::DataGlossaryAndChapter->new();	
	my $dqr =  oaperlapi::DataQueryRequest->new();
	my $dqrc =  oaperlapi::DataQueryRequestForAClass->new();
	my $MC = oaperlapi::ManagedClassIdentifier->new();
	my $MCFdn = oaperlapi::ManagedClassFdn->new();	
	
	my %stored_filter = %{$self->{Filter}};	
        my $filter_cnt = scalar (keys (%stored_filter));	
	    
	if ($filter_cnt)
	{    
		my @attrib = ("SystemHostName");
		$self->GetInstanceDetails(\@attrib);
		my $idl = $self->{Idl};
		$accessClient = $self->{accessclient};
		$MC = $self->{MC};		
		SetInstanceFilterInDqrc($idl,$dqrc);

	}	
	else
	{
		$MC->SetName( oaperlapi::String_t->new($self->{Class}));
		$MC->SetDomain(oaperlapi::String_t->new($self->{Domain}));		
		$accessClient->FetchModel($mqr, $model);
		$dqrc->SetFetchAllInstancesFlag(1);   
	}        
        
        $MCFdn->AddContainedManagedClass($MC);
        
	$dqrc->SetManagedClass($MCFdn);
	$dqrc->SetFetchEventsFlag(1);
	 
        $dqr->AddDataQueryRequestForAClass($dqrc);
	
	my $time_now = time();
	my $start_time = $time_now - $self->{Policy_interval} * 60;
	$dqr->SetStartTime($start_time);
	$dqr->SetEndTime($time_now);
	$dqr->SetSumInterval($self->{Policy_interval} * 60 );
	$dqr->SetPiggyBackChapterSize(10000);
	
	$accessClient->FetchDataGlossaryAndChapter($dqr, $dgc);
	my $dg = $dgc->GetDataGlossary();
	my $dc = $dgc->GetDataChapter();
	my $num_pages = $dc->GetDataChapterListSize();
	
	my $Buffer="";
	my $ElementName;
	my $uuid;
	my $dp;
	my $num_classese;
	
	for(my $k=0; $k<$num_pages; $k++)
	{	  
	  $dp = $dc->GetDataPageAt($k);
	  $num_classese = $dp->GetDataPageListSize();	  
	  my $dp4c;
	  my $dg4c;
	  my $classid;
	  my $num_instances;
	  for(my $l=0; $l<$num_classese; $l++)	  
	  {		
	     $dp4c = $dp->GetDataPageForAClassAt($l);
	     $dg4c = $dg->GetDataGlossaryForAClassAt($l);
	     $classid = $dg4c->GetManagedClassId();	     
	     $num_instances = $dp4c->GetNumInstances();
	     my $instid;
	     my $num_events;
	     my $instFdn;
	     my $MBS_instFdn_str;
	     my $Fdn_chain_len;
	     my $inst;
	     my $num_inst_construct;
	     for(my $m=0; $m<$num_instances; $m++)
	     {
	       $Buffer="";
	       $instid = $dg4c->GetInstanceIdAt($m);
	       $num_events = $dp4c->GetNumEventsForInstanceAt($m);	     
		if (!$num_events)
		{
			next;
		}
	       $instFdn = $dg4c->GetInstanceFdnAt($m);
	       $MBS_instFdn_str = oaperlapi::MBS_t->new($instFdn->GetInstanceFdnString());
	       $Fdn_chain_len = $instFdn->GetInstanceChainLength();
	       $inst = $instFdn->GetInstanceAt($Fdn_chain_len -1) ;
	       my $num_attrib = $inst->GetNumAttributes();
	       $num_inst_construct = $inst->GetNumInstanceConstructs();
	       my $MIVP;
	       my $metid;
	       my $str_metid;
	       my $metVal;
	       my $fqdn = "";
	      
		$MIVP =  $inst->GetInstanceConstructAt(0);
		$metid =  $MIVP->GetMetricIdentifier();
		$str_metid = oaperlapi::MBS_t->new($metid->GetName())->ToCharPtr();
		$metVal = $MIVP->GetValue();
		$uuid =  oaperlapi::MBS_t->new($metVal->GetValueAsString())->ToCharPtr(); 

		$MIVP =  $inst->GetInstanceConstructAt(1);
		$metid =  $MIVP->GetMetricIdentifier();
		$str_metid = oaperlapi::MBS_t->new($metid->GetName())->ToCharPtr();
		$metVal = $MIVP->GetValue();
		$ElementName =  oaperlapi::MBS_t->new($metVal->GetValueAsString())->ToCharPtr();
				
		for(my $attrib_cnt = 0 ; $attrib_cnt < $num_attrib;$attrib_cnt++)
		{
			$MIVP = $inst->GetAttributeAt($attrib_cnt);
			$metid =$MIVP->GetMetricIdentifier();
			$str_metid = oaperlapi::MBS_t->new($metid->GetName())->ToCharPtr();					
			$metVal =oaperlapi::MBS_t->new($MIVP->GetValue()->GetValueAsString())->ToCharPtr();	
			if ( lc($metVal) eq "na" or $metVal eq "-"  or $metVal  eq "" )
			{
				$metVal = "NA";
			}
			if ($metVal eq "NA")
			{
				$fqdn = $ElementName;
			}
			else
			{
				$fqdn = $metVal;
			}			
							
		}
		
		if ($fqdn eq "")
		{
			$fqdn = $ElementName;
		}
		
		my $evt;
		my $evtType;
		my $evtDesc;
		my $creattime;
		my $MBS_evtType;
		my $MBS_evtDesc;
		my $MBS_creattime;
		my $formatted_time;      
		for(my $n=0; $n<$num_events; $n++)
		{				
			 $evt = $dp4c->GetEventAt($m,$n);
			 $evtType = $evt->GetType();
			 $evtDesc = $evt->GetDescription();
			 $creattime = $evt->EventObservedTime();
			 $MBS_evtType = oaperlapi::MBS_t->new($evtType);
			 $MBS_evtDesc = oaperlapi::MBS_t->new($evtDesc);
			 $MBS_creattime = oaperlapi::MBS_t->new($creattime);
			 $formatted_time = format_time($MBS_creattime->ToCharPtr(),0);
			 $Buffer = $MBS_evtType->ToCharPtr()."| ".$formatted_time."| ".$uuid."| ".$ElementName."| ".$MBS_evtDesc->ToCharPtr();			
			 push (@{$event_hash{$fqdn}},$Buffer);
		}
     	     }
	  }
	}
	return \%event_hash;

}
sub format_time
{
	my ($arg, $getfirsthour) = @_;
	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = gmtime($arg);
	$hour=1 if ( $getfirsthour );
	my $hrs = $hour + ($yday * 24);
	($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime ($arg);
	$hour=1 if ( $getfirsthour );
	my $tz = ($hour + ($yday * 24)) - $hrs;
	$year = $year + 1900;
	$mon = $mon + 1;
	my $string = sprintf("%.4d-%.2d-%.2dT%.2d:%.2d:%.2d%+.2d:00", $year, $mon, $mday, $hour, $min, $sec, $tz);
	return $string;
}
sub GetInstanceList()
{
        my ( $self,$loca_ldl) = @_;        
        my @instancelist = ();
        my $num_idl4c = $loca_ldl->GetNumInstanceDetailsListForAClass();
        for(my $i=0; $i<$num_idl4c; $i++)
        {                
                my $idl4c = $loca_ldl->GetInstanceDetailsListForAClassAt($i);
                my $MBS_McFdn_str = oaperlapi::MBS_t->new($idl4c->GetManagedClassFdn()->GetManagedClassFdnString());
                my $num_inst = $idl4c->GetNumInstanceDetails();
                for(my $j=0; $j<$num_inst; $j++)
                {                        
                        my $instDetails = $idl4c->GetInstanceDetailsAt($j);
                        my $instFdn = $instDetails->GetInstanceFdn();
                        my $MBS_instFdn_str = oaperlapi::MBS_t->new($instFdn->GetInstanceFdnString());                        
                        my $inst_id_0 = oaperlapi::MBS_t->new($instFdn->GetInstanceAt(0)->GetInstanceConstructAt(0)->GetValue()->GetValueAsString())->ToCharPtr();
                        my $inst_id_1 = oaperlapi::MBS_t->new($instFdn->GetInstanceAt(0)->GetInstanceConstructAt(1)->GetValue()->GetValueAsString())->ToCharPtr();
                        my $inst_id = join(':',$inst_id_1,$inst_id_0);
                        push (@instancelist,$inst_id);                        
                }
        }
        return \@instancelist;
}

sub GetInstanceDetails()
{
        my ($self,$AttribArrRef) = @_;
        
        my @AttribArr = @$AttribArrRef;
        
        my $accessClient = oaperlapi::OAAccess->new();
        my $mqr = oaperlapi::ModelQueryRequest->new();
        my $model = oaperlapi::MetricModel->new();
        my $iqr = oaperlapi::InstanceQueryRequest->new();
        my $idl  = oaperlapi::InstanceDetailsList->new();
        my $iqr4c = oaperlapi::InstanceQueryRequestForAClass->new();
 	my $as4c = oaperlapi::AttributeSelectionListForAClass->new();       
        
        my $MC = oaperlapi::ManagedClassIdentifier->new();
        my $MCFdn = oaperlapi::ManagedClassFdn->new();

        $MC->SetName( oaperlapi::String_t->new($self->{Class}));
        $MC->SetDomain(oaperlapi::String_t->new($self->{Domain}));
        $MCFdn->AddContainedManagedClass($MC);

        my $dgc = oaperlapi::DataGlossaryAndChapter->new();
        my $dqr =  oaperlapi::DataQueryRequest->new();
        my $dqrc =  oaperlapi::DataQueryRequestForAClass->new();

        my $filter = oaperlapi::Filter->new();

        $iqr4c->SetManagedClassFdn($MCFdn);
        
        my $attrib_cnt =  scalar (@AttribArr);
        
        if ($attrib_cnt)
        {       	
        	
        	for (my $cnt=0;$cnt < $attrib_cnt ; $cnt++)
        	{
        		my $Attrib_Name_str = oaperlapi::String_t->new($AttribArr[$cnt]);
        		$as4c->AddAttributeName($Attrib_Name_str);
        	}        	
        	
		$as4c->SelectAllAttributes(0);	
		
        }
	else
	{
		$as4c->SelectAllAttributes(1);
	}
	
	$as4c->SetManagedClass($MC);
        $iqr->AddAttributeSelectionListForAClass($as4c);

        my %stored_filter = %{$self->{Filter}};

        my $filter_cnt = scalar (keys (%stored_filter));
        my @filt_keys = keys (%stored_filter);

        my @MetricIdArr = undef;
        my @MetricValArr = undef;
        my @ClauseArr    = undef;

        for (my $cnt=0;$cnt < $filter_cnt ; $cnt++)
        {
                $MetricIdArr[$cnt]  = oaperlapi::MetricIdentifier->new();
                $MetricValArr[$cnt] = oaperlapi::Value->new();
                $ClauseArr[$cnt]    = oaperlapi::FilterClause->new();

                $MetricIdArr[$cnt]->SetName(oaperlapi::String_t->new($filt_keys[$cnt]));
                $MetricValArr[$cnt]->SetValueFromString($oaperlapi::a1_mdt_utf16, oaperlapi::String_t->new($stored_filter{$filt_keys[$cnt]}));

                $ClauseArr[$cnt]->SetMetric($MetricIdArr[$cnt]);
                $ClauseArr[$cnt]->AddValueToList($MetricValArr[$cnt]);
                $ClauseArr[$cnt]->SetOperator($oaperlapi::oper_equal_to);

                $filter->AddClause($ClauseArr[$cnt]);

        }
        my $clause_cnt = scalar (@ClauseArr ) - 1;
        for (my $i=1;$i <= $clause_cnt ; $i++)
        {
                $filter->AddAdjoinOperator($oaperlapi::adjoin_oper_and);
        }

	if (scalar (keys (%stored_filter)))
        {
		$iqr4c->SetFilter($filter);
	}
        $iqr->AddInstanceQueryRequestForAClass($iqr4c);
        
        my $time_now = time();
	my $start_time = $time_now - $self->{Policy_interval}* 3 * 60;
		
	$iqr->SetStartTime($start_time);
	$iqr->SetEndTime($time_now);
	
        $self->{accessclient} = $accessClient;
        
        $accessClient->FetchInstances($iqr, $idl);
        
        $self->{Idl} = $idl;
        $self->{MC} = $MC;
 	
	return 0;      
}

sub setfilter()
{
        my $self = shift;
        my $FilterRef = shift;
        my %FilterHash = %$FilterRef;
        $self->{Filter} = $FilterRef;
}

sub PrintInstanceDetails
{
        my ( $loca_ldl) = @_;
        my $num_idl4c = $loca_ldl->GetNumInstanceDetailsListForAClass();
        my $tmpstr = "";
        for(my $i=0; $i<$num_idl4c; $i++)
        {
                my $idl4c = $loca_ldl->GetInstanceDetailsListForAClassAt($i);
                my $MBS_McFdn_str = oaperlapi::MBS_t->new($idl4c->GetManagedClassFdn()->GetManagedClassFdnString());
                
                my $num_inst = $idl4c->GetNumInstanceDetails();
                for(my $j=0; $j<$num_inst; $j++)
                {
                        my $instDetails = $idl4c->GetInstanceDetailsAt($j);
                        my $instFdn = $instDetails->GetInstanceFdn();
                        my $MBS_instFdn_str = oaperlapi::MBS_t->new($instFdn->GetInstanceFdnString());

                        #$tmpstr.=oaperlapi::MBS_t->new($instFdn->GetInstanceFdnString())->ToCharPtr()."\n";

                }
        } 

}

sub SetInstanceFilterInDqrcByFdn
{
        my ($local_Dqrc,$Fdn_ArrRef) = @_;
        my @Fdn_Arr = @$Fdn_ArrRef;
        my $Fdn_cnt = scalar(@Fdn_Arr);
        for(my $j=0; $j< $Fdn_cnt; $j++)
        {
                my $Instance = oaperlapi::Instance->new();
                my $InstFdn = oaperlapi::InstanceFdn->new();
                my $MetId     = oaperlapi::MetricIdentifier->new();
                my $mivp     = oaperlapi::MetricIdentifierValuePair->new();
                my $value    = oaperlapi::Value->new();
                my $value_1    = oaperlapi::Value->new();
                my $MetId_1     = oaperlapi::MetricIdentifier->new();
                my $mivp_1     = oaperlapi::MetricIdentifierValuePair->new();

                my @key = split(/:/,$Fdn_Arr[$j]);               
                my $sys_name = "$key[0]";
		        my $sys_id = "$key[1]";

                $MetId->SetName(oaperlapi::String_t->new("SystemID"));
                $MetId->SetType($oaperlapi::a1_mdt_utf16);
                $MetId->SetCategory($oaperlapi::a1_mct_key);                
		$MetId->SetKeySequenceNumber(0);
                $mivp->SetMetricIdentifier($MetId);
                $value->SetValueFromString($oaperlapi::a1_mdt_utf16,oaperlapi::String_t->new($sys_id));
                $mivp->SetValue($value);
                $Instance->AddInstanceConstruct($mivp);

                $MetId_1->SetName(oaperlapi::String_t->new("SystemName"));
                $MetId_1->SetType($oaperlapi::a1_mdt_utf16);
                $MetId_1->SetCategory($oaperlapi::a1_mct_key);
		$MetId_1->SetKeySequenceNumber(1);
                $mivp_1->SetMetricIdentifier($MetId_1);
                $value_1->SetValueFromString($oaperlapi::a1_mdt_utf16,oaperlapi::String_t->new($sys_name));
                $mivp_1->SetValue($value_1);
                $Instance->AddInstanceConstruct($mivp_1);

                $InstFdn->AddContainedInstance($Instance);

                my $MBS_instFdn_str = oaperlapi::MBS_t->new($InstFdn->GetInstanceFdnString());

                $local_Dqrc->AddInstanceFilter($InstFdn);
        }
}
		
sub SetInstanceFilterInDqrc
{
        my ( $loca_ldl,$local_Dqrc) = @_;
        my $num_idl4c = $loca_ldl->GetNumInstanceDetailsListForAClass();
        for(my $i=0; $i<$num_idl4c; $i++)
        {
                my $idl4c = $loca_ldl->GetInstanceDetailsListForAClassAt($i);
                my $MBS_McFdn_str = oaperlapi::MBS_t->new($idl4c->GetManagedClassFdn()->GetManagedClassFdnString());
                my $num_inst = $idl4c->GetNumInstanceDetails();
                for(my $j=0; $j<$num_inst; $j++)
                {
                       my $instDetails = $idl4c->GetInstanceDetailsAt($j);
                       my  $instFdn = $instDetails->GetInstanceFdn();
                        $local_Dqrc->AddInstanceFilter($instFdn);
                }
        }

}

sub GetDsAssociations()
{
        my $self = shift;
        my ($Domain,$Class) = @_;  
        my %asso_hash;
        
        my $accessClient = oaperlapi::OAAccess->new();
        my $mqr = oaperlapi::ModelQueryRequest->new();
        my $model = oaperlapi::MetricModel->new();
        my $iqr = oaperlapi::InstanceQueryRequest->new();
        my $dsnode_idl  = oaperlapi::InstanceDetailsList->new();
        my $iqr4c = oaperlapi::InstanceQueryRequestForAClass->new();
 	my $MC = oaperlapi::ManagedClassIdentifier->new();
        my $MCFdn = oaperlapi::ManagedClassFdn->new();
	
        $MC->SetName( oaperlapi::String_t->new($Class));
        $MC->SetDomain(oaperlapi::String_t->new($Domain));
        $MCFdn->AddContainedManagedClass($MC);
        $iqr4c->SetManagedClassFdn($MCFdn);
	
        $iqr->AddInstanceQueryRequestForAClass($iqr4c); 
       	
        $accessClient->FetchInstances($iqr, $dsnode_idl); 
        #PrintInstanceDetails($dsnode_idl);
        
        my $DsHashRef = GetDsHash($self,$dsnode_idl);       
        my %Ds_hash = %{$DsHashRef};
	
        my $idl = $self->{Idl};
        my $num_idl4c = $idl->GetNumInstanceDetailsListForAClass();
        
        for(my $i=0; $i<$num_idl4c; $i++)
	    {
		    my $idl4c = $idl->GetInstanceDetailsListForAClassAt($i);	
		    my $num_inst = $idl4c->GetNumInstanceDetails();
		    for(my $j=0; $j<$num_inst; $j++)
		    {
			   my $instDetails = $idl4c->GetInstanceDetailsAt($j);
			   my $instFdn = $instDetails->GetInstanceFdn();
			    my $MBS_instFdn_str = oaperlapi::MBS_t->new($instFdn->GetInstanceFdnString());
			    my $guestid_0 = oaperlapi::MBS_t->new($instFdn->GetInstanceAt(0)->GetInstanceConstructAt(0)->GetValue()->GetValueAsString())->ToCharPtr();

			my $guestid_1 = oaperlapi::MBS_t->new($instFdn->GetInstanceAt(0)->GetInstanceConstructAt(1)->GetValue()->GetValueAsString())->ToCharPtr();
			my $guestid = join(':',$guestid_1,$guestid_0);
			    if ($Ds_hash{$guestid})
			    {
				    $asso_hash{$guestid} = $Ds_hash{$guestid};
			    }
		     }
	    } 
        
	return  \%asso_hash;      
}

sub GetDsHash()
{
	my ($self,$dsnode_idl) = @_;
	my %ds_hash;
	my $num_idl4c = $dsnode_idl->GetNumInstanceDetailsListForAClass();
	        
	for(my $i=0; $i<$num_idl4c; $i++)
	{
		my $idl4c = $dsnode_idl->GetInstanceDetailsListForAClassAt($i);
		my $MBS_McFdn_str = oaperlapi::MBS_t->new($idl4c->GetManagedClassFdn()->GetManagedClassFdnString());

		my $num_inst = $idl4c->GetNumInstanceDetails();
		for(my $j=0; $j<$num_inst; $j++)
		{
			my $instDetails = $idl4c->GetInstanceDetailsAt($j);
			my $instFdn = $instDetails->GetInstanceFdn();
			my $inst = $instFdn->GetInstanceAt($instFdn->GetInstanceChainLength() - 1);
			my $num_attrib = $inst->GetNumAttributes();

			my $DsName = oaperlapi::MBS_t->new($instFdn->GetInstanceAt(0)->GetInstanceConstructAt(1)->GetValue()->GetValueAsString())->ToCharPtr();
			
			my $MIVP;
			my $metVal;
			my $metid;
			
			#Datastore_ID
			$MIVP =  $inst->GetInstanceConstructAt(0);
			
			$metid =$MIVP->GetMetricIdentifier();
			$metVal =oaperlapi::MBS_t->new($MIVP->GetValue()->GetValueAsString())->ToCharPtr();			
			
			my $MIVP1;
			my $metVal1;
			my $metid1;
			
			$MIVP1 = $inst->GetInstanceConstructAt(1);
			$metid1 =$MIVP1->GetMetricIdentifier();
			$metVal1 =oaperlapi::MBS_t->new($MIVP1->GetValue()->GetValueAsString())->ToCharPtr();
			
			my $ds_key = join(':',$metVal1,$metVal);
            $MIVP = $inst->GetInstanceConstructAt(2);
            $metid =$MIVP->GetMetricIdentifier();
            $metVal =oaperlapi::MBS_t->new($MIVP->GetValue()->GetValueAsString())->ToCharPtr();
            $MIVP1 = $inst->GetInstanceConstructAt(3);
            $metid1 =$MIVP1->GetMetricIdentifier();
            $metVal1 =oaperlapi::MBS_t->new($MIVP1->GetValue()->GetValueAsString())->ToCharPtr();
			my $ds_node = join(':',$metVal1,$metVal);
			push (@{$ds_hash{$ds_node}},$ds_key);
			
		}
	}
	return \%ds_hash ; 
}

sub PrintInstConstruct()
{
	my $inst = shift;
	my $num_inst_construct = $inst->GetNumInstanceConstructs();
	my $MIVP;
	my $metid;
	my $str_metid;
	my $metVal;
	for(my $i=0; $i < $num_inst_construct;$i++)
	{
		$MIVP =  $inst->GetInstanceConstructAt($i);
		$metid =  $MIVP->GetMetricIdentifier();
		$str_metid = oaperlapi::MBS_t->new($metid->GetName())->ToCharPtr();
		$metVal = $MIVP->GetValue();
	}
}

sub getTypeDisplayName
{
 my @cats = ('U', 'NA', 'KEY', 'ATTR',	'STATE', 'DELTA',  'GAUGE',  'COUNTER',  'VAR', 	'PEAK',  'LOW' );  
 my @dtypes = (   	'U',    	'INT',    	'REAL',    	'BOOLEAN',    	'STR',    	'TIME',    	'NONE'  );
  
  my($param1,$param1Type) = @_;
  if($param1Type eq "cat") {
    if($param1 <=10) {
        return $cats[$param1];
    }
  }
  elsif ($param1Type eq "dtype") {
    if($param1 <= 6) {
       return $dtypes[$param1];
    }
  }
}

sub getModel 
{  
        
  my $self = shift;
    my $accessClient = oaperlapi::OAAccess->new();
    $self->{accessclient} = $accessClient;
  
    my $MC 				= $self->{Class};
    my $DOM				= $self->{Domain};
  	
    #Arg1
    my $mfilter			= shift;
  		
    my $mqr 			= oaperlapi::ModelQueryRequest->new();  
    my $model 			= oaperlapi::MetricModel->new();   
      
    my @metricArr 		= @$mfilter;
      
    my $MetFilter		= 1;    
    if(scalar(@metricArr) <= 0) { $MetFilter = 0;};
      
    $accessClient->FetchModel($mqr, $model);      
    my $numClasses 		= $model->GetManagedClassDefnCount();
    my %retmetrichash   = ();
      
  for(my $idx = 0; $idx < $numClasses; $idx++) {
      	
  		my $mcdef 	= $model->GetManagedClassDefnAt($idx);  		
  		my $mcname = $mcdef->GetManagedClassName();  	  	
    		
  		my $MBS_mcname = oaperlapi::MBS_t->new($mcname);  		  	
  
    		if($MBS_mcname->ToCharPtr() eq $MC) 
    		{
    			my $numMetrics = $mcdef->GetMetricDefnCount();
			for(my $idx1 = 0; $idx1 < $numMetrics; $idx1++)
  			{
				my @prop = ();
  				my $propindex=0;
  				my $key;
  				
  				#Get metric Defintion
  				my $metdef = $mcdef->GetMetricDefnAt($idx1);
  				
  				#Get name
  				my $metname 		= $metdef->GetMetricName();
  				my $MBS_metname 	= oaperlapi::MBS_t->new($metname);
  				
                                  if($MetFilter == 1) {
  				   my $found_metric=0;
                                     if ( my @found = grep { $_ eq $MBS_metname->ToCharPtr() } @metricArr )
                                     {
                                       $found_metric = 1;
                                     }
  
                                          #Skip the metric to output
  					if($found_metric == 0){
  				           next;	
  					}				
  				} 
  				
  				$prop[$propindex] 	= $MBS_metname->ToCharPtr();
  				$key 				= $MBS_metname->ToCharPtr();
                                  
  				#Get Category
  				my $mettype 		= $metdef->GetMetricCategoryType();
                                  my $mettypestr 		= getTypeDisplayName($mettype, 'cat');
                                  $propindex = $propindex + 1;
  				$prop[$propindex] 	= $mettypestr; 
  				
  				#Get Data type
  				my $metdatatype 	= $metdef->GetMetricDataType();
  				my $metdatatypestr 	= getTypeDisplayName($metdatatype, 'dtype');
  				$propindex = $propindex + 1;
  				$prop[$propindex] 	= $metdatatypestr; 
                  
                  #Get Label
  				my $metlab 			= $metdef->GetLabel();
  				$propindex			= $propindex + 1;
  				$prop[$propindex] 	= (oaperlapi::MBS_t->new($metlab))->ToCharPtr();
  				
  				#Get Description
  				my $metdesc 		= $metdef->GetDescription();
  				$propindex			= $propindex + 1;
  				$prop[$propindex] 	= (oaperlapi::MBS_t->new($metdesc))->ToCharPtr();				
  			    
  			    #Push prop in return hash
                              $retmetrichash{$key} = [@prop];
  			#for Metrics
  			} 
          }
      #for Classes
      }
    return \%retmetrichash;
}

1;