package VMwareConnection;
use strict;
use warnings;
use VMware::VIRuntime;

sub new {
	my $self = {
	    connected => 0,
	    available_intervals => undef,
	    perfmgr => undef,
	    counters_hash => undef,
	    use_refresh_rate => 1
	};
	bless($self, shift);
}

sub connect {
	my $self = shift;
	return if ($self->{connected});
	Util::connect();
	$self->{connected} = 1;
}

sub disable_refresh_rate_usage {
	my $self = shift;
	$self->{use_refresh_rate} = 0;
}

sub enable_refresh_rate_usage {
	my $self = shift;
	$self->{use_refresh_rate} = 1;
}

sub disconnect {
	my $self = shift;
	return if (!$self->{connected});
	Util::disconnect();
	$self->{connected} = 0;
}

sub get_perfmgr {
	my $self = shift;
	return $self->{perfmgr} if (defined $self->{perfmgr});

	$self->{perfmgr} =  Vim::get_view(
	    mo_ref => Vim::get_service_content()->perfManager
	);

	return $self->{perfmgr};
}

sub get_available_intervals {
	my $self = shift;
	$self->get_perfmgr();
	return $self->{perfmgr}->historicalInterval;
}

sub get_system_wide_counters {
	my $self = shift;
	my $perfcounterinfo;
	my $key;
	
	if (defined $self->{counters_hash}) {
		return $self->{counters_hash};
	}

	$self->get_perfmgr();
	$perfcounterinfo = $self->{perfmgr}->perfCounter;

	# get all available metrics(counters)
	foreach (@$perfcounterinfo) {
		$key = $_->key;
		$self->{counters_hash}->{$key} = $_;
	}

	return $self->{counters_hash};
}

sub get_available_counters {
	my $self = shift;
	my $entity = shift;
	my $avail_counters_ids;

	if (!defined $entity) {
		die('invalid empty entity');
	}

	$self->get_perfmgr();
	$avail_counters_ids = $self->{perfmgr}->QueryAvailablePerfMetric(
	    entity => $entity
	);

	return $avail_counters_ids;
}

sub get_counter_info {
	my $self = shift;
	my $counter_id = shift;
	my $system_counters;

	$self->get_system_wide_counters();
	if (!defined $self->{counters_hash}->{$counter_id}) {
		die('unable to locate counter id');
	}

	return $self->{counters_hash}->{$counter_id};
}

sub get_views {
	my $self = shift;
	my $managed_object = shift;
	my $views;

	$views = Vim::find_entity_views(
	    view_type => $managed_object
	);

	return $views;
}

sub get_view {
	my $self = shift;
	my $name = shift;
	my $type = shift;
	my $obj;

	if (!defined $name) {
		die('invalid empty view name');
	}

	if (!defined $type) {
		die('invalid empty view type');
	}

	$obj = Vim::find_entity_view(
	    view_type => $type,
	    filter => {
	        'name' => $name
	    }
	);

	if (!defined $obj) {
		die("unable to locate $type view $name");
	}

	return $obj;
}

sub get_refresh_rate_for_entity {
	my $self = shift;
	my $entity = shift;
	my $summary;
	
	$self->get_perfmgr();
	$summary = $self->{perfmgr}->QueryPerfProviderSummary(
	    entity => $entity
	);

	if ($summary->refreshRate) {
		return $summary->refreshRate;
	}

	return 0;
}

sub collect_counter {
	my $self =  shift;
	my $entity = shift;
	my $counter_id = shift;
	my @acounter;
	my $perf_query_spec;
	my $perf_data;
	my $intervals;
	my $refresh;
	my $interval;
	my $counter;

	if (!defined $entity) {
		die('invalid empty entity');
	}

	if (!defined $counter_id) {
		die('invalid empty counter id');
	}

	$refresh = 0;
	if ($self->{use_refresh_rate}) {
		$refresh = $self->get_refresh_rate_for_entity($entity);
	}

	if ($refresh == 0) {
		$intervals = $self->get_available_intervals();
		$interval = shift @$intervals;
		$refresh = $interval->{samplingPeriod};
	}

	$counter = PerfMetricId->new(
	   counterId => $counter_id,
	   instance => ''
	);

	push(@acounter, $counter);

	$perf_query_spec = PerfQuerySpec->new(
	    entity => $entity,
	    metricId => \@acounter,
	    format => 'normal',
	    intervalId => $refresh,
	    maxSample => 1
	);

	$self->get_perfmgr();
	$perf_data = $self->{perfmgr}->QueryPerf(
	    querySpec => $perf_query_spec
	);


	return shift @$perf_data;
}


1;