#!perl -w
#
# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of the License "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description:
#
use strict;

#
# A simple class to manage feature flags for a feature set data file.
#
package HCRrec;

my %typemap = (
    Int32 =>       0x00000001,
    Int16 =>       0x00000002,    
    Int8 =>        0x00000004,
    Bool =>        0x00000008,    
    UInt32 =>      0x00000010,
    UInt16 =>      0x00000020,    
    UInt8 =>       0x00000040,
    LinAddr =>     0x00000100,
    BinData =>     0x00010000,
    Text8 =>       0x00020000,    
	ArrayInt32 =>  0x00040000,
	ArrayUInt32 => 0x00080000,
    Int64 =>       0x01000000,
    UInt64 =>      0x02000000,    
);
my %maptype = reverse %typemap;
my %lsdtype2packmap = (
    0x00010000 => "C",
    0x00020000 => "a",    
    0x01000000 => "C",
    0x02000000 => "C",    
);

# Create a feature flag object.
sub new
{
	my $arg = shift;
	my $class = ref($arg) || $arg;

	my $self = {
			     cuid => 0,              # 4 bytes
			     eid => 0,               # 4 bytes
			     type => 0,              # 4 bytes
			     flagword => 0x0000,     # 2 bytes 
                 valueset => 0,
                           
			     intvalue => 0,           # 4 bytes
			     strvalue => "",          # array of chars
			     binvalue => [],          # array of bytes
			     arrvalue => [],		  # array of 4 byte integers
			     
   				 endian => "LE",
			   };
 
	bless $self, $class;
	return $self;
}

sub Endian
{
	my $self = shift;
	return undef unless(ref($self));
	my $arg = shift;
	return $self->{endian} unless(defined($arg) and $arg =~ m/(^BE$|^LE$)/i);
	$self->{endian} = lc($1);
	return $self->{endian};
}

# Return a twelve byte string 'feature flag' information.
sub GetRecHdrBinary
{
	my $self = shift;
	return undef unless(ref($self));
	
	my $lsd_size = shift;
	
	my $stype = $self->Type(); 
	my @hdrarr = ( $self->CUID(), $self->EID(), $stype, $self->Flags(),
                $self->SizeInBytes() );
    
	# Decide whether we want big or little endian output.
	# According to the documentation, 'V', 'N' are GUARANTEED to be 32-bit.
	my $packstring;
	if($self->Endian() eq "BE") {
	    $packstring = "N3n2N";
        }
    else {
        $packstring = "V3v2V"; # Little endian.
        }
        
    #
    # Could add range checks here for 8-bit and 16-bit types.
    # However would stop negative test cases from being generated.
    # Do it later.
    #
    
    if ($stype & 0xffff) {
        print "Writing integer\n" if ($mhd::otrace);
        push @hdrarr, $self->IntValue();
        }
    
    if ($stype & 0xffff0000) {
        if ($self->Length() > 0) {
            print "Writing offset: " . $lsd_size . "\n" if ($mhd::otrace);
            push @hdrarr, $lsd_size;
            }
        else {
            print "Writing null offset: 0\n" if ($mhd::otrace);
            push @hdrarr, 0;            
            }
        }

	my $hdr_string = pack $packstring, @hdrarr;
	
	return $hdr_string;
}

# Return a twelve byte string 'feature flag' information.
# Assumes Little Endian output!
sub GetRecLsdBinary
{
	my $self = shift;
	return undef unless(ref($self));
	
    my $value = "";
    my $valuelen = $self->Length();
    my $vallen = $valuelen;
    #print "vallen before:" . $vallen . "\n";
    $vallen = ($valuelen+3)&0xfffc if ($valuelen%4) ;
    #print "vallen after:" . $vallen . "\n";
	my $valtype = $self->{type};

    # String
    if ($valtype & 0x00020000) {
	    my $packstr = $lsdtype2packmap{$valtype} . $vallen;
	    printf ("packstr:%s\n", $packstr) if($mhd::otrace);
        printf ("strvalue:%s\n", $self->{strvalue}) if($mhd::otrace);
        $value = pack $packstr,  $self->{strvalue} ;
        }
    # Binary Data
    elsif ($valtype & 0x00010000) {
        for (my $c=0;  $c < $valuelen; $c++) {
            my $byte = $self->{binvalue}[$c];
            $value .= pack $lsdtype2packmap{$valtype}, $byte;
            $vallen--;     
        }
        while ($vallen > 0) {
            $value .= pack "C", ( 0x00 );
            $vallen--;
            }
    }
    # 64bit quantity
    elsif ($valtype & 0x03000000) {
        die "error: 64 bit integer missing hex binvalues\n" if (! exists $self->{binvalue}[7]);
        $value  = pack $lsdtype2packmap{$valtype}, $self->{binvalue}[0];
        $value  .= pack $lsdtype2packmap{$valtype}, $self->{binvalue}[1];
        $value  .= pack $lsdtype2packmap{$valtype}, $self->{binvalue}[2];
        $value  .= pack $lsdtype2packmap{$valtype}, $self->{binvalue}[3];
        $value  .= pack $lsdtype2packmap{$valtype}, $self->{binvalue}[4];
        $value  .= pack $lsdtype2packmap{$valtype}, $self->{binvalue}[5];
        $value  .= pack $lsdtype2packmap{$valtype}, $self->{binvalue}[6];
        $value  .= pack $lsdtype2packmap{$valtype}, $self->{binvalue}[7];
        }
    # array of 32bit quantity
    elsif ($valtype & 0x000C0000) {
        for (my $c=0;  $c < $valuelen; $c++) {
            my $int = $self->{arrvalue}[$c];
            $value .= pack "V", $int;
            $vallen--;     
            }
	}    
    else {
        die "panic: proramming error!!";
    }
    
	return $value;
	}

# A single 32-bit number.
sub CUID
{
	my $self = shift;
	return undef unless(ref($self));
	my $uid = shift;
	return $self->{cuid} unless(defined($uid));
	my $uidv = hex($uid);
	$self->{cuid} = $uidv;
	return $uidv;
}

# A single 32-bit number.
sub EID
{
	my $self = shift;
	return undef unless(ref($self));
	my $id = shift;
	return $self->{eid} unless(defined($id));
	my $idv = int($id);
	$self->{eid} = $idv;
	return $idv;
}

sub Type
{
	my $self = shift;
	return undef unless(ref($self));
	my $type = shift;
	return $self->{type} unless(defined($type));
	my $enum = $typemap{$type};
	#print "--->Defined\n" if (defined $enum);
	#print "--->NOT Defined\n" if (! defined $enum);
	die "error: unknown setting type found in input file\n" if (! defined $enum);
   	$self->{type} = $enum;
	return $enum;
}

sub TypeName
{
	my $self = shift;
	return undef unless(ref($self));
	return "Undefined Type" if (! exists $maptype{$self->{type}});
	return $maptype{$self->{type}};
}

sub Flags
{
	my $self = shift;
	return undef unless(ref($self));
	my $flags = shift;
	return $self->{flagword} unless(defined($flags));
	my $vf = hex($flags);
	$self->{flagword} = $vf;
	return $vf;
}

sub Length
{
	my $self = shift;
	return undef unless(ref($self));
	my $len = shift;
	die "panic: Length() does not take an argument!\n" if (defined($len));
	
	my $length = 0;
	if ($self->{type} & 0x00020000) {
        $length = length ($self->{strvalue});
        }
    elsif ($self->{type} & 0x03010000) {
	    my $array_ref = $self->{binvalue};
	    my @array = @$array_ref;
	    $length = $#array+1;
	    }
    elsif ($self->{type} & 0x000C0000) {
	    my $array_ref = $self->{arrvalue};
	    my @array = @$array_ref;
	    $length = $#array+1;
	    #printf ("arrval length %d %d\n",  length ($self->{arrval}), $length);
	    }
	else {
	    $length = 0;
        }
	return $length;	
}

sub SizeInBytes
{
	my $self = shift;
	return undef unless(ref($self));
	my $len = shift;
	die "panic: Length() does not take an argument!\n" if (defined($len));
	
	my $size = 0;
	if ($self->{type} & 0x00020000) {
        $size = length ($self->{strvalue});
        }
    elsif ($self->{type} & 0x03010000) {
	    my $array_ref = $self->{binvalue};
	    my @array = @$array_ref;
	    $size = $#array+1;
	    }
    elsif ($self->{type} & 0x000C0000) {
	    my $array_ref = $self->{arrvalue};
	    my @array = @$array_ref;
	    $size = ($#array+1)*4;
	    #printf ("arrval length %d %d\n",  length ($self->{arrval}), $length);
	    }
	else {
	    $size = 0;
        }
	return $size;	
}

sub IsValid
{
	my $self = shift;
	return undef unless(ref($self));

    if (($self->{cuid} == 0) || ($self->{eid} == 0) ||
        ($self->{type} == 0) || ($self->{flagword} != 0) ||
        ($self->IsValueSet() == 0)) {
        return 0;
        }    
    
    #Record valid if we reach here
    return 1;    
}

sub IsValueSet
{
	my $self = shift;
	return undef unless(ref($self));
	return $self->{valueset};
}

sub MarkValueSet
{
	my $self = shift;
	return undef unless(ref($self));
	$self->{valueset} = 1;
}

sub IntValue
{
	my $self = shift;
	return undef unless(ref($self));
	my $value = shift;
	if (defined($value)) {
        my $int = int($value);
        $self->{intvalue} = $int;
        $self->MarkValueSet();
        }
	return $self->{intvalue};
}

sub HexValue
{
	my $self = shift;
	return undef unless(ref($self));
	my $value = shift;
	return $self->{intvalue} unless(defined($value));
	my $int = hex($value);
	$self->{intvalue} = $int;
	$self->MarkValueSet();
    return $int;
}

sub StrValue
{
	my $self = shift;
	return undef unless(ref($self));
	my $value = shift;
	return $self->{strvalue} unless(defined($value));
	#printf ("strlen before %d\n", length ($self->{strvalue}));	
    $self->{strvalue} .= $value;
	#printf ("strlen after %d\n",  length ($self->{strvalue}));
	$self->MarkValueSet();
    return $value;
}

sub ArrValue
{
	my $self = shift;
	return undef unless(ref($self));
	my $value = shift;

	return $self->{arrvalue} unless(defined($value));

    my $int = int($value);
	my $index = $self->Length();

	$self->{arrvalue}[$index] = $int; # Increments the array size as well as appending item
	$index*=4; 

	printf ("warning: array value larger than HCR maximum (512 bytes): %d\n", $index) if ($index > 512);    
	$self->MarkValueSet();

    return $self->{arrvalue};
}

sub BinValue
{
	my $self = shift;
	return undef unless(ref($self));
	my $value = shift;
	
	return $self->{binvalue} unless(defined($value));

    my @hwords = split(/\s/,$value);
    shift @hwords if ($hwords[0] eq "");
    my $hwordslen = scalar(@hwords);  

    #printf("(len:%d)(0:%04x 1:%04x last:%04x)\n", $hwordslen, hex($hwords[0]), hex($hwords[1]), hex($hwords[$hwordslen-1])) if ($mhd::trace);
    
    my $index = $self->Length();
	#printf ("binlen before %d\n", $index);
         
    #print "Index: " . $index . "\n";
    foreach my $word (@hwords) {
        if (length ($word) == 2) {
	        $self->{binvalue}[$index] = hex($word);
            }
        else {
            die "error: hexadecimal value '$word' too short/large for 8-bit integer\n";
            }


	   #$self->{binvalue}[$index] = $mint;
	   #printf("%d: %04x\n", $count, $self->{binvalue}[$count]);
       $index++;	  
	   }
	  

	#printf ("binlen after %d\n", $index);
            
    printf ("warning: binary value larger than HCR maximum (512 bytes): %d\n", $index) if ($index > 512);
    $self->MarkValueSet();            
	return $self->{binvalue};
}


# ###########################################################################

1;