<?php

include_once('FileStream.php');
include_once('MemoryStream.php');

define('NOT_DBC_FILE', 'Není DBC soubor.');
define('RECORD_SIZE_NOT_MATCH', 'Velikost řádku neodpovídá zadanému formátu.');

define('DBC_SIGNATURE', 0x43424457);

define('FORMAT_UINT32', 0);
define('FORMAT_SINT32', 1);
define('FORMAT_SINGLE', 2);
define('FORMAT_STRING', 3);
define('FORMAT_BYTE', 4);

class DBCFile extends FileStream
{
  private $HeaderSize = 20;
  private $Offsets;
  private $StringOffset;
  private $StringList = array();
  private $StringListOffset = array();
  private $ColumnFormat; // Array (Index => Type)
  private $EndOffset; // Calculated RecordSize according columns type

  private $RecordSize;
  private $RecordCount;
  private $StringBlockSize;
  private $FieldCount;

  public function OpenFile($FileName, $ColumnFormat = array())
  {
    parent::OpenFile($FileName);

    $this->ColumnFormat = $ColumnFormat;
    if ($this->ReadUint() != DBC_SIGNATURE) die(NOT_DBC_FILE);

    $this->RecordCount = $this->ReadUint();
    $this->FieldCount = $this->ReadUint();
    $this->RecordSize = $this->ReadUint();
    $this->StringBlockSize = $this->ReadUint();

    $this->GenerateOffsetTable();
    if ($this->EndOffset != $this->RecordSize)
    die(RECORD_SIZE_NOT_MATCH.$this->EndOffset.' <> '.$this->RecordSize);
  }

  public function CreateFile($FileName, $ColumnFormat = array())
  {
    parent::CreateFile($FileName);

    $this->WriteUint(DBC_SIGNATURE);

    $this->StringList = array();
    $this->StringOffset = 1;
    $this->ColumnFormat = $ColumnFormat;
    $this->FieldCount = 0;
    $this->GenerateOffsetTable();
    $this->RecordCount = 0;
    $this->RecordSize = $this->EndOffset;
    $this->StringBlockSize = 0;

    $this->WriteUint($this->RecordCount);
    $this->WriteUint($this->FieldCount);
    $this->WriteUint($this->RecordSize);
    $this->WriteUint($this->StringBlockSize);
  }

  private function GenerateOffsetTable()
  {
    // Preallocate array
    if ($this->FieldCount > 0) $this->Offsets = array_fill(0, $this->FieldCount, 0);
      else $this->Offsets = array();

    $Offset = 0;
    $I = 0;
    while ($I < $this->FieldCount)
    {
      $this->Offsets[$I] = $Offset;
      if (array_key_exists($I, $this->ColumnFormat)) $Format = $this->ColumnFormat[$I];
        else $Format = FORMAT_UINT32;
      switch ($Format)
      {
        case FORMAT_BYTE:
          $Offset += 1;
          break;
        case FORMAT_UINT32:
        case FORMAT_SINT32:
        case FORMAT_SINGLE:
        case FORMAT_STRING:
          $Offset += 4;
          break;
      }
      $I++;
    }
    $this->EndOffset = $Offset;
  }

  private function CellPos($Row, $Column)
  {
    return $this->HeaderSize + $Row * $this->RecordSize + $this->Offsets[$Column];
  }

  public function GetByte($Row, $Column)
  {
    $this->SetPosition($this->CellPos($Row, $Column));
    return $this->ReadByte();
  }

  public function GetUInt($Row, $Column)
  {
    $this->SetPosition($this->CellPos($Row, $Column));
    return $this->ReadUint();
  }

  public function GetInt($Row, $Column)
  {
    $this->SetPosition($this->CellPos($Row, $Column));
    return $this->ReadInt();
  }

  public function GetFloat($Row, $Column)
  {
    $this->SetPosition($this->CellPos($Row, $Column));
    return $this->ReadFloat();
  }

  public function SetByte($Row, $Column, $Value)
  {
    $this->SetPosition($this->CellPos($Row, $Column));
    $this->WriteByte($Value);
  }

  public function SetUint($Row, $Column, $Value)
  {
    $this->SetPosition($this->CellPos($Row, $Column));
    $this->WriteUint($Value);
  }

  public function SetInt($Row, $Column, $Value)
  {
    $this->SetPosition($this->CellPos($Row, $Column));
    $this->WriteInt($Value);
  }

  public function SetFloat($Row, $Column, $Value)
  {
    $this->SetPosition($this->CellPos($Row, $Column));
    $this->WriteFloat($Value);
  }

  public function GetString($Row, $Column)
  {
    $Offset = $this->GetUint($Row, $Column);

    $Position = $this->HeaderSize + $this->RecordCount * $this->RecordSize + $Offset;
    if ($Position >= $this->GetSize()) return '';
    $this->SetPosition($Position);

    $String = '';
    while (($Char = $this->ReadChar()) != "\0")
    {
      $String .= $Char;
    }
    return $String;
  }

  public function SetString($Row, $Column, $Value)
  {
    if (in_array($Value, $this->StringList))
    {
      $this->SetUint($Row, $Column, $this->StringListOffset[array_search($Value, $this->StringList)]);
    } else
    {
      $this->SetUint($Row, $Column, $this->StringOffset);
      $this->StringList[] = $Value;
      $this->StringListOffset[] = $this->StringOffset;
      $this->StringOffset += strlen($Value) + 1;
    }
  }

  public function Commit()
  {
    $this->SetSize($this->HeaderSize + $this->RecordSize * $this->RecordCount); // Preallocate file
    $this->SetPosition(0);
    $this->WriteUint(DBC_SIGNATURE);
    $this->WriteUint($this->RecordCount);
    $this->WriteUint($this->FieldCount);
    $this->WriteUint($this->RecordSize);
    $this->WriteUint($this->StringOffset);
    $this->SetPosition($this->HeaderSize + $this->RecordCount * $this->RecordSize);
    $this->WriteByte(0);
    foreach ($this->StringList as $Index => $Item)
    {
      $this->WriteString($Item."\0");
    }
  }

  public function GetLine($Row)
  {
    // Cache record data
    $Record = new MemoryStream();
    $this->SetPosition($this->CellPos($Row, 0));
    $Record->Data = $this->ReadBlock($this->RecordSize);

    // Preallocate array
    if ($this->FieldCount > 0) $Line = array_fill(0, $this->FieldCount, 0);
      else $Line = array();
    for ($I = 0; $I < $this->FieldCount; $I++)
    {
      if (array_key_exists($I, $this->ColumnFormat)) $Format = $this->ColumnFormat[$I];
        else $Format = FORMAT_UINT32;
      $Record->SetPosition($this->Offsets[$I]);
      switch ($Format)
      {
        case FORMAT_BYTE:
          $Line[$I] = $Record->ReadByte();
          break;
        case FORMAT_UINT32:
          $Line[$I] = $Record->ReadUInt();
          break;
        case FORMAT_SINT32:
          $Line[$I] = $Record->ReadInt();
          break;
        case FORMAT_SINGLE:
          $Line[$I] = $Record->ReadFloat();
          break;
        case FORMAT_STRING:
          $Offset = $Record->ReadUint();

          $Position = $this->HeaderSize + $this->RecordCount * $this->RecordSize + $Offset;
          if ($Position >= $this->GetSize()) $String = '';
          else
          {
            $this->SetPosition($Position);
            $String = '';
            while (($Char = $this->ReadChar()) != "\0")
              $String .= $Char;
          }
          $Line[$I] = $String;
          break;
        default:
          break;
      }
    }
    return $Line;
  }

  public function SetLine($Row, $Line)
  {
    // Cache record data
    $Record = new MemoryStream();

    for ($I = 0; $I < $this->FieldCount; $I++)
    {
      if (array_key_exists($I, $this->ColumnFormat)) $Format = $this->ColumnFormat[$I];
        else $Format = FORMAT_UINT32;
      $Record->SetPosition($this->Offsets[$I]);
      switch ($Format)
      {
        case FORMAT_BYTE:
          $Record->WriteByte($Line[$I]);
          break;
        case FORMAT_UINT32:
          $Record->WriteUint($Line[$I]);
          break;
        case FORMAT_SINT32:
          $Record->WriteInt($Line[$I]);
          break;
        case FORMAT_SINGLE:
          $Record->WriteFloat($Line[$I]);
          break;
        case FORMAT_STRING:
          if (in_array($Line[$I], $this->StringList))
          {
            $Record->WriteUint($this->StringListOffset[array_search($Line[$I], $this->StringList)]);
          } else
          {
            $Record->WriteUint($this->StringOffset);
            $this->StringList[] = $Line[$I];
            $this->StringListOffset[] = $this->StringOffset;
            $this->StringOffset += strlen($Line[$I]) + 1;
          }
          break;
        default:
          break;
      }
    }

    $this->SetPosition($this->CellPos($Row, 0));
    $this->WriteBlock($Record->Data, $this->RecordSize);
    return $Line;
  }

  public function GetRecordCount()
  {
    return $this->RecordCount;
  }

  public function SetRecordCount($Value)
  {
    $this->RecordCount = $Value;
  }

  public function GetFieldCount()
  {
    return $this->FieldCount;
  }

  public function SetFieldCount($Value)
  {
    $this->FieldCount = $Value;
    $this->GenerateOffsetTable();
    $this->RecordSize = $this->EndOffset;
  }
}