<?php

class blockchain
{
  private static $url_info = 'https://blockchain.info/fr';
  private static $offline_block = OFFLINE_PATH.'/offline_block.zip';
  /*
   * Liste de blocks spéciaux dans l'histoire du Bitcoin
   *
   * 'GENESIS'     - Premier block de la blochain
   * 'THE_ANSWER'  - Block 42 (pour le fun)
   * 'LUCIFER'     - Block 666 (pour le fun)
   * 'LEET'        - Block 1337 (pour le fun)
   * 'PIZZA'       - Block 57035 : le block du pizza day, 22 05 2010
   * 'HALVING_1'   - First halving, block 2100000, 28 11 2012
   * 'HALVING_2'   - Second halving, block 420000, 09 07 2017
   * 'BIP_91_LOCK' - Block 477120 : Verouillage du BIP 91, 23/07/2017
   * 'BCC'         - Block 478558 : Bitcoin Cash Fork 01/08/2017
   * 'SEGWIT_LOCK' - Block 479808 SEGWIT est verrouillé 09 08 2017
   * 'SEGWIT'      - Block 481823 SEGWIT est activé 24 08 2017
   */
  private static $special_blocks = array (
    'GENESIS'     => '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f',
    'THE_ANSWER'  => '00000000314e90489514c787d615cea50003af2023796ccdd085b6bcc1fa28f5',
    'LUCIFER'     => '00000000fc5b3c76f27f810ee775e480ae7fd604fd196b2d8da4257fcd39f4f9',
    'LEET'        => '000000008bf44a528a09d203203a6a97c165cf53a92ecc27aed0b49b86a19564',
    'TOPISTO'     => '000000000a73e64735a2b75c97ea674950a9018da1420d01328a918c9ff9852c',
    'PIZZA'       => '00000000006de085dadb3ec413ef074022fe781121b467e98960280dd246bb00',
    'HALVING_1'   => '000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e',
    'HALVING_2'   => '000000000000000002cce816c0ab2c5c269cb081896b7dcb34b8422d6b74ffa1',
    'BIP_91_LOCK' => '0000000000000000015411ca4b35f7b48ecab015b14de5627b647e262ba0ec40',
    'BCC'         => '00000000000000000019f112ec0a9982926f1258cdcc558dd7c3b7e5dc7fa148',
    'SEGWIT_LOCK' => '0000000000000000012e6060980c6475a9a8e62a1bf44b76c5d51f707d54522c',
    'SEGWIT'      => '000000000000000000cbeff0b533f8e1189cf09dfbebf57a8ebe349362811b80',
    'HURRICANE_1' => '0000000000000000000fe6d521a187a5523d5cef6f6c178923ff82ffe5a0f372',
    'WHALE201810' => '0000000000000000000f9f2dadfb8f312572183272802cbfcc4ff95b4ee6777d',
    'BLOCK21E800' => '00000000000000000021e800c1e8df51b22c1588e5a624bea17e9faa34b2dc4a'   
  );

  // ---
  // --- Retourne le nom d'un block à partie de son hash
  // ---   si ce n'est pas un block special, on renvoie le hash
  // --- 
  public static function hash2SpecialName($block_hash)
  {
    foreach(self::$special_blocks as $key => $value)
      if ($block_hash == $value) return $key;

    return $block_hash;
  }

  // ---
  // --- Accès aux blocks spéciaux
  // ---    On en rajoute un : le LAST block
  // ---    En fait toute valeur ne faisant pas partie des blocks connus
  // --- 
  public static function getSpecialBlock($nom_du_block)
  {
    $block_hash = '';

    if (isset(self::$special_blocks[$nom_du_block])) $block_hash = self::$special_blocks[$nom_du_block];

    if (file_exists(self::$offline_block)) $block_hash = 'offline';

    if ($block_hash == '') $block_hash = self::getLastBlockHash();

    return self::getBlockWithHash($block_hash);
  }

  // ---
  // --- Accès au dernier block en cache ...
  // --- 
  public static function getLastCacheBlockHash()
  {
    // on commence par le cache d'images
    $myarray = glob(DATA_PATH.'/hasard/*.png');
    if (isset($myarray[0]))
    {
      usort( $myarray, function( $a, $b ) { return filemtime($b) - filemtime($a); } );
      return substr(basename($myarray[0],'.png'),0,strlen(self::$special_blocks['GENESIS']));
    }

    // S'il n'y a rien dans le cache d'images
    $filename=DATA_PATH.'/finished_block_list.txt';

    if (file_exists($filename))
    {
      $handle = fopen($filename, "r");
      if ($handle)
      {
        while (($buffer = fgets($handle, 4096)) !== false) {
          $valeurs = explode(" ",$buffer);
          if ($valeurs[0] == 'LAST') return $valeurs[1];
        }
      }
    }

    return NULL;
  }

  // ---
  // --- Accès au dernier block
  // --- 
  public static function getLastBlockHash()
  {
    if (file_exists(self::$offline_block)) return 'offline';

    $filename=self::$url_info.'/latestblock';
    $message = file_get_contents($filename);
    if ($message === FALSE) return FALSE;
    $the_block = json_decode($message);
    return $the_block->hash;
  }

  // ---
  // --- Accès à partir du hash
  // --- 
  public static function getBlockWithHash($block_hash)
  {
    // Si on est offline, peut importe le hash passé
    if (!file_exists(self::$offline_block)) 
    {
      if (!file_exists(DATA_PATH."/json/$block_hash.zip"))
      {
      	$filename=self::$url_info.'/rawblock/'.$block_hash;
      	$message = file_get_contents($filename);
      	if ( $message === FALSE ) return FALSE;
      	$the_block = json_decode($message);
      	return self::saveBlockInTmpDir($the_block);
      }
      touch(DATA_PATH."/json/$block_hash.zip");
    }
    return self::zip2Block($block_hash);
  }

  // ---
  // --- Gestion du cache
  // ---
  private static function saveBlockInTmpDir($the_block)
  {
    if (file_exists(DATA_PATH.'/json/'.$the_block->hash.'.zip')) return $the_block;

    if (!isset($the_block->topisto_inputs))
    {
      $the_block->topisto_inputs  = 0;
      $the_block->topisto_outputs = 0;
      $the_block->topisto_fees    = 0;
      $the_block->topisto_reward  = 0;

      foreach($the_block->tx as $transaction)
      {
        $tx_inputs = 0;
        $tx_outputs = 0;

        if (isset($transaction->inputs))
          foreach($transaction->inputs as $input)
            if (isset($input->prev_out->value))
              $tx_inputs += $input->prev_out->value;

        if (isset($transaction->out))
          foreach($transaction->out as $output)
            if (isset($output->value))
              $tx_outputs += $output->value;
  
        $tx_fees = abs($tx_inputs - $tx_outputs);
        $the_block->topisto_inputs  += $tx_inputs;

        if ($tx_inputs == 0)
        {
          $the_block->topisto_reward += $tx_outputs;
          continue;
        }

        $the_block->topisto_outputs += $tx_outputs;
        $the_block->topisto_fees += $tx_fees;
      }
      // On retire les frais de la récompense
      $the_block->topisto_reward -= $the_block->topisto_fees;

      self::block2zip($the_block);
    }

    return $the_block;
  }

  private static function block2zip($the_block)
  {
    $zip = new ZipArchive();
    if($zip->open(DATA_PATH.'/json/'.$the_block->hash.'.zip', ZipArchive::CREATE) === true)
    {
      $zip->addFromString($the_block->hash.'.json', json_encode($the_block));
      $zip->close();
    }
  }

  private static function zip2Block($the_block_hash)
  {
    $local_hash = $the_block_hash;
    $zipBlock = DATA_PATH."/json/$the_block_hash.zip";
    if (file_exists(self::$offline_block)) 
    {
      $local_hash = 'offline';
      $zipBlock = self::$offline_block;
    }

    $zip = new ZipArchive;

    if ($zip->open($zipBlock) === TRUE) {
      $the_block = json_decode($zip->getFromName("$local_hash.json"));
      $zip->close();
      return $the_block;
    }
    return NULL;
  }

  public static function DrawBlockHeaderFooter($the_block, $vImage, $hauteur, $couleur = -1)
  {
    $color_tab = [
      [
        [19,15,64],
        [255,255,255]
      ],
      [
        [106,176,76],
        [0,0,0]
      ],
      [
        [106,176,76],
        [255,255,255]
      ],
      [
        [240,147,43],
        [0,0,0]
      ],
      [
        [34,166,179],
        [0,0,0]
      ],
      [
        [240,147,43],
        [255,255,255]
      ],
      [
        [48,51,107],
        [255,255,255]
      ],
      [
        [246, 229, 141],
        [235,77,75]
      ],
      [
        [40, 40, 40],
        [158,227,253]
      ],
      [
        [255, 255, 255],
        [0, 0, 0]
      ],
      [
        [0, 0, 0],
        [255, 255, 255]
      ],
      [
        [255, 255, 255],
        [255, 0, 0]
      ]
    ];

    $color = $couleur;
    if ($color == -1) $color = rand(0,count($color_tab)-1);

    // Rajout des HASHES
    $white = imagecolorallocate($vImage, 254, 254, 254);
    $black = imagecolorallocate($vImage, $color_tab[$color][1][0], $color_tab[$color][1][1], $color_tab[$color][1][2]);
    $fond  = imagecolorallocate($vImage, $color_tab[$color][0][0], $color_tab[$color][0][1], $color_tab[$color][0][2]);
    $w = imagesx($vImage);
    $h = imagesy($vImage);

    // On rend le blanc transparent
    imagecolortransparent($vImage, $white);

    // On place un fond transparent
    imagefilledrectangle($vImage, 0, 0, $w, $h, $white);

    $len     = strlen($the_block->hash);
    $ratio_w = ($w - 10) / $len;
    $ratio_h = $hauteur / 32; // car hexadécimal

    // Récupérer les hashes dans 2 tableaux
    $tableau1 = str_split($the_block->hash);
    $tableau2 = str_split($the_block->prev_block);

    // Convertir les tableaux en liste de points
    $points1 = [];
    $points2 = [];

    $points1[] = 0;
    $points1[] = $hauteur - 1;

    $points2[] = 0;
    $points2[] = $hauteur - 1;

    for($i=0;$i<$len;$i++)
    {
      // Le HASH
      $coin_x1 = $ratio_w * $i; 
      $coin_x2 = $ratio_w * ($i + 1);
      $coin_y1 = $hauteur;
      $coin_y2 = 5 + hexdec($tableau1[$i])*$ratio_h;

      $points1[] = $coin_x1;
      $points1[] = $coin_y2;
      $points1[] = $coin_x2;
      $points1[] = $coin_y2;
      
      // Le PREV HASH 
      $coin_x1 = $ratio_w * $i; 
      $coin_x2 = $ratio_w * ($i + 1);
      $coin_y1 = $hauteur;
      $coin_y2 = 25 - hexdec($tableau2[$i])*$ratio_h;

      $points2[] = $coin_x1;
      $points2[] = $coin_y2;
      $points2[] = $coin_x2;
      $points2[] = $coin_y2;
    }

    // Rajouter une barre au HASH
    $coin_x1 = $ratio_w * $i; 
    $coin_x2 = $ratio_w * ($i + 1);
    $coin_y1 = $hauteur;
    $coin_y2 = 5;
    
    $points1[] = $coin_x1;
    $points1[] = $coin_y2;
    $points1[] = $coin_x2;
    $points1[] = $coin_y2;
          
    // Rajouter une barre au PREV HASH 
    $coin_x1 = $ratio_w * $i; 
    $coin_x2 = $ratio_w * ($i + 1);
    $coin_y1 = $hauteur;
    $coin_y2 = 25;
    
    $points2[] = $coin_x1;
    $points2[] = $coin_y2;
    $points2[] = $coin_x2;
    $points2[] = $coin_y2;
    
    // Rajouter un coin
    $points1[] = $w;
    $points1[] = $hauteur - 1;

    $points2[] = $w;
    $points2[] = $hauteur - 1;

    // Inverser le PREV HASH
    for($i=0;$i<count($points2);$i+=2)
    {
      $points2[$i+1] = $h - $points2[$i+1];
      if ($points2[$i+1] >= $h) $points2[$i+1] = $h - 1;
    }

    // Dessiner le HASH
    imagefilledpolygon($vImage, $points1, (count($points1)/2), $fond);
    imagepolygon($vImage, $points1, (count($points1)/2), $black);
   
    // Dessiner le PREV HASH
    imagefilledpolygon($vImage, $points2, (count($points2)/2), $fond);
    imagepolygon($vImage, $points2, (count($points2)/2), $black);

    // Rajout des textes
    $the_name = blockchain::hash2SpecialName($the_block->hash);
    if ($the_name == $the_block->hash) $the_name = date('Ymd H:i:s', $the_block->time);

    putenv('GDFONTPATH='.RESS_PATH.'/fonts/');
    $font = 'DS-DIGIB.TTF';

    $the_texte = "Height : ".$the_block->height;
    imagettftext($vImage,18, 0, 5, $hauteur-5, $black, $font, $the_texte);
    $the_texte = "Inputs : ".$the_block->topisto_inputs;
    if (count($the_block->tx)==1) $the_texte = "Reward : ".$the_block->topisto_reward;
    imagettftext($vImage, 15, 0, 25, ($h - $hauteur)+18, $black, $font, $the_texte);
    
    $bbox = imagettfbbox(14, 0, $font, $the_name);
    imagettftext($vImage, 14, 0, ($w-3)-($bbox[2]-$bbox[0]), ($hauteur-5), $black, $font, $the_name);

    return [$white, $fond, $black, $font, $color_tab[$color][1], $color_tab[$color][0]];
  }

  public static function getTransactionData($the_block, $type=1)
  {
    // Cela a déjà été calculé 
    if (isset($the_block->data[$type])) return $the_block->data[$type];

    $data = [];
    foreach($the_block->tx as $transaction)
    {
      $total_outputs = 0;
      $total_inputs  = 0;
      $value         = 0;

      if (isset($transaction->out))
        foreach($transaction->out as $output)
          if (isset($output->value))
            $total_outputs += $output->value;

      if (isset($transaction->inputs))
        foreach($transaction->inputs as $input)
          if (isset($input->prev_out->value))
            $total_inputs += $input->prev_out->value;

      switch($type)
      {
        // OUTPUTS
        case 1:
          if ($total_inputs != 0)
            $data[] = ["hash" => $transaction->hash, "value" => $total_outputs];
          break;

        // INPUTS
        case 2:
          $data[] = ["hash" => $transaction->hash, "value" => $total_inputs];
          break;

        // FEES
        case 3:
          if ($total_inputs != 0)
            $data[] = ["hash" => $transaction->hash, "value" => ($total_outputs-$total_inputs)];
          break;

        // REWARD
        case 4:
          if ($total_inputs == 0)
            $data[] = ["hash" => $transaction->hash, "value" => $total_outputs];
          break;
      }
    }
    if (!isset($the_block->data)) $the_block->data = [];
    $the_block->data[$type] = $data;
    return $data;
  }  
}

?>