package ber

import (
	"bytes"
	"fmt"
   "io"
   "os"
	"reflect"
)

type Packet struct {
	ClassType uint8
	TagType uint8
	Tag uint8
   Value interface{}
	Data *bytes.Buffer
   Children []*Packet
   Description string
}

const (
	TagEOC              = 0x00
	TagBoolean          = 0x01
	TagInteger          = 0x02
	TagBitString        = 0x03
	TagOctetString      = 0x04
	TagNULL             = 0x05
	TagObjectIdentifier = 0x06
	TagObjectDescriptor = 0x07
	TagExternal         = 0x08
	TagRealFloat        = 0x09
	TagEnumerated       = 0x0a
	TagEmbeddedPDV      = 0x0b
	TagUTF8String       = 0x0c
	TagRelativeOID      = 0x0d
	TagSequence         = 0x10
	TagSet              = 0x11
	TagNumericString    = 0x12
	TagPrintableString  = 0x13
	TagT61String        = 0x14
	TagVideotexString   = 0x15
	TagIA5String        = 0x16
	TagUTCTime          = 0x17
	TagGeneralizedTime  = 0x18
	TagGraphicString    = 0x19
	TagVisibleString    = 0x1a
	TagGeneralString    = 0x1b
	TagUniversalString  = 0x1c
	TagCharacterString  = 0x1d
	TagBMPString        = 0x1e
	TagBitmask          = 0x1f // xxx11111b
)

var TagMap = map[uint8] string {
	TagEOC              : "EOC (End-of-Content)",
	TagBoolean          : "Boolean",
	TagInteger          : "Integer",
	TagBitString        : "Bit String",
	TagOctetString      : "Octet String",
	TagNULL             : "NULL",
	TagObjectIdentifier : "Object Identifier",
	TagObjectDescriptor : "Object Descriptor",
	TagExternal         : "External",
	TagRealFloat        : "Real (float)",
	TagEnumerated       : "Enumerated",
	TagEmbeddedPDV      : "Embedded PDV",
	TagUTF8String       : "UTF8 String",
	TagRelativeOID      : "Relative-OID",
	TagSequence         : "Sequence and Sequence of",
	TagSet              : "Set and Set OF",
	TagNumericString    : "Numeric String",
	TagPrintableString  : "Printable String",
	TagT61String        : "T61 String",
	TagVideotexString   : "Videotex String",
	TagIA5String        : "IA5 String",
	TagUTCTime          : "UTC Time",
	TagGeneralizedTime  : "Generalized Time",
	TagGraphicString    : "Graphic String",
	TagVisibleString    : "Visible String",
	TagGeneralString    : "General String",
	TagUniversalString  : "Universal String",
	TagCharacterString  : "Character String",
	TagBMPString        : "BMP String",
}

const (
	ClassUniversal   =   0  // 00xxxxxxb
	ClassApplication =  64  // 01xxxxxxb
	ClassContext     = 128  // 10xxxxxxb
	ClassPrivate     = 192  // 11xxxxxxb
	ClassBitmask     = 192  // 11xxxxxxb
)

var ClassMap = map[uint8] string {
	ClassUniversal   : "Universal",
	ClassApplication : "Application",
	ClassContext     : "Context",
	ClassPrivate     : "Private",
}

const (
	TypePrimative   =  0  // xx0xxxxxb
	TypeConstructed = 32  // xx1xxxxxb
	TypeBitmask     = 32  // xx1xxxxxb
)

var TypeMap = map[uint8] string {
	TypePrimative   : "Primative",
	TypeConstructed : "Constructed",
}

var Debug bool = false

func PrintBytes( buf []byte, indent string ) {
   data_lines := make( []string, ( len( buf ) / 30 ) + 1 )
   num_lines := make( []string, ( len( buf ) / 30 ) + 1 )

   for i, b := range buf {
      data_lines[ i / 30 ] += fmt.Sprintf( "%02x ", b )
      num_lines[ i / 30 ] += fmt.Sprintf( "%02d ", ( i + 1 ) % 100 )
   }

   for i := 0; i < len( data_lines ); i++ {
      fmt.Print( indent + data_lines[ i ] + "\n" )
      fmt.Print( indent + num_lines[ i ] + "\n\n" )
   }
}

func PrintPacket( p *Packet ) {
   printPacket( p, 0, false )
}

func printPacket( p *Packet, indent int, printBytes bool ) {
	indent_str := ""
	for len(indent_str) != indent {
		indent_str += " "
	}

   class_str := ClassMap[ p.ClassType ]
   tagtype_str := TypeMap[ p.TagType ]
   tag_str := fmt.Sprintf( "0x%02X", p.Tag )

   if p.ClassType == ClassUniversal {
      tag_str = TagMap[ p.Tag ]
   }

   value := fmt.Sprint( p.Value )
   description := ""
   if p.Description != "" {
      description = p.Description + ": "
   }

   fmt.Printf( "%s%s(%s, %s, %s) Len=%d %q\n", indent_str, description, class_str, tagtype_str, tag_str, p.Data.Len(), value )

   if printBytes {
      PrintBytes( p.Bytes(), indent_str )
   }

   for _, child := range p.Children {
      printPacket( child, indent + 1, printBytes )
   }
}

func resizeBuffer( in []byte, new_size uint64 ) (out []byte) {
   out = make( []byte, new_size )
   copy( out, in )
   return
}

func readBytes( reader io.Reader, buf []byte ) os.Error {
   idx := 0
   buflen := len( buf )
   for idx < buflen {
      n, err := reader.Read( buf[ idx: ] )
      if err != nil {
         return err
      }
      idx += n
   }
   return nil
}

func ReadPacket( reader io.Reader ) ( *Packet, os.Error) {
   buf := make([]byte, 2)
   err := readBytes( reader, buf )
   if err != nil {
      return nil, err
   }
   idx := uint64(2)
   datalen := uint64(buf[1])
   if Debug {
      fmt.Printf( "Read: datalen = %d len(buf) = %d ", datalen, len( buf ) )
      for _, b := range buf {
         fmt.Printf( "%02X ", b )
      }
      fmt.Printf( "\n" )
   }
   if datalen & 128 != 0 {
      a := datalen - 128
      idx += a
      buf = resizeBuffer( buf, 2 + a )
      err := readBytes( reader, buf[2:] )
      if err != nil {
         return nil, err
      }
      datalen = DecodeInteger( buf[ 2:2+a ] )
      if Debug {
         fmt.Printf( "Read: a = %d  idx = %d  datalen = %d  len(buf) = %d", a, idx, datalen, len( buf ) )
         for _, b := range buf {
            fmt.Printf( "%02X ", b )
         }
         fmt.Printf( "\n" )
      }
   }

   buf = resizeBuffer( buf, idx + datalen )
   err = readBytes( reader, buf[idx:] )
   if err != nil {
      return nil, err
   }

   if Debug {
      fmt.Printf( "Read: len( buf ) = %d  idx=%d datalen=%d idx+datalen=%d\n", len( buf ), idx, datalen, idx + datalen )
      for _, b := range buf {
         fmt.Printf( "%02X ", b )
      }
   }

   p := DecodePacket( buf )
   return p, nil
}

func DecodeString( data []byte ) (ret string) {
   for _, c := range data {
      ret += fmt.Sprintf( "%c", c )
	}
	return
}

func DecodeInteger( data []byte ) (ret uint64) {
   for _, i := range data {
		ret = ret * 256
		ret = ret + uint64(i)
	}
	return
}

func EncodeInteger( val uint64 ) []byte {
	var out bytes.Buffer
	found := false
	shift := uint(56)
	mask := uint64(0xFF00000000000000)
	for mask > 0 {
		if !found && ( val & mask != 0 ) {
			found = true
		}
		if found || ( shift == 0 ) {
			out.Write( []byte { byte( ( val & mask ) >> shift ) } )
		}
		shift -= 8
		mask = mask >> 8
	}
	return out.Bytes()
}

func DecodePacket( data []byte ) *Packet {
   p, _ := decodePacket( data )
   return p
}

func decodePacket( data []byte ) (*Packet, []byte) {
   if Debug {
      fmt.Printf( "decodePacket: enter %d\n", len( data ) )
   }
   p := new( Packet )
   p.ClassType = data[0] & ClassBitmask
   p.TagType = data[0] & TypeBitmask
   p.Tag = data[0] & TagBitmask

   datalen := DecodeInteger( data[1:2] )
   datapos := uint64(2)
   if datalen & 128 != 0 {
      datalen -= 128
      datapos += datalen
      datalen = DecodeInteger( data[2:2+datalen] )
   }

   p.Data = new( bytes.Buffer )
   p.Children = make( []*Packet, 0, 2 )
   p.Value = nil

   value_data := data[datapos:datapos+datalen]

   if p.TagType == TypeConstructed {
      for len( value_data ) != 0 {
         var child *Packet
         child, value_data = decodePacket( value_data )
         p.AppendChild( child )
      }
   } else if p.ClassType == ClassUniversal {
      p.Data.Write( data[datapos:datapos+datalen] )
		switch p.Tag {
			case TagEOC:
			case TagBoolean:
            val := DecodeInteger( value_data )
				p.Value = val != 0
			case TagInteger:
            p.Value = DecodeInteger( value_data )
			case TagBitString:
			case TagOctetString:
            p.Value = DecodeString( value_data )
			case TagNULL:
			case TagObjectIdentifier:
			case TagObjectDescriptor:
			case TagExternal:
			case TagRealFloat:
			case TagEnumerated:
            p.Value = DecodeInteger( value_data )
			case TagEmbeddedPDV:
			case TagUTF8String:
			case TagRelativeOID:
			case TagSequence:
			case TagSet:
			case TagNumericString:
			case TagPrintableString:
            p.Value = DecodeString( value_data )
			case TagT61String:
			case TagVideotexString:
			case TagIA5String:
			case TagUTCTime:
			case TagGeneralizedTime:
			case TagGraphicString:
			case TagVisibleString:
			case TagGeneralString:
			case TagUniversalString:
			case TagCharacterString:
			case TagBMPString:
		}
   } else {
      p.Data.Write( data[datapos:datapos+datalen] )
   }

   return p, data[ datapos + datalen: ]
}

func (p *Packet) DataLength() uint64 {
	return uint64( p.Data.Len() )
}

func (p *Packet) Bytes() []byte {
	var out bytes.Buffer
	out.Write( []byte { p.ClassType | p.TagType | p.Tag } )
	packet_length := EncodeInteger( p.DataLength() )
	if p.DataLength() > 127 || len( packet_length ) > 1 {
		out.Write( []byte { byte( len( packet_length ) | 128 ) } )
		out.Write( packet_length )
	} else {
		out.Write( packet_length )
	}
	out.Write( p.Data.Bytes() )
	return out.Bytes()
}

func (p *Packet) AppendChild( child *Packet ) {
	p.Data.Write( child.Bytes() )
   if len( p.Children ) == cap( p.Children ) {
      newChildren := make( []*Packet, cap( p.Children ) * 2 )
      copy( newChildren, p.Children )
      p.Children = newChildren[0:len(p.Children)]
   }
   p.Children = p.Children[ 0:len(p.Children) + 1 ]
   p.Children[ len( p.Children ) - 1 ] = child
}

func Encode( ClassType, TagType, Tag uint8, Value interface{}, Description string ) *Packet {
	p := new( Packet )
	p.ClassType = ClassType
	p.TagType = TagType
	p.Tag = Tag
	p.Data = new( bytes.Buffer )
   p.Children = make( []*Packet, 0, 2 )
   p.Value = Value
   p.Description = Description

	if Value != nil {
		v := reflect.NewValue(Value)

		if ( ClassType == ClassUniversal ) {
			switch Tag {
				case TagOctetString:
					sv, ok := v.Interface().(string)
					if ok {
						p.Data.Write( []byte(sv) )
					}
			}
		}
	}

	return p
}

func NewSequence( Description string) *Packet {
   return Encode( ClassUniversal, TypePrimative, TagSequence, nil, Description )
}

func NewBoolean( ClassType, TagType, Tag uint8, Value bool, Description string ) *Packet {
   intValue := 0
   if Value {
      intValue = 1
   }

   p := Encode( ClassType, TagType, Tag, nil, Description )
   p.Value = Value
   p.Data.Write( EncodeInteger( uint64(intValue) ) )
   return p
}

func NewInteger( ClassType, TagType, Tag uint8, Value uint64, Description string ) *Packet {
   p := Encode( ClassType, TagType, Tag, nil, Description )
   p.Value = Value
   p.Data.Write( EncodeInteger( Value ) )
   return p
}

func NewString( ClassType, TagType, Tag uint8, Value, Description string ) *Packet {
   p := Encode( ClassType, TagType, Tag, nil, Description )
   p.Value = Value
   p.Data.Write( []byte( Value ) )
   return p
}