<?php

$DivisionCount = 500;
$ReferenceTime = 0;
$LevelReducing = 5;
$MaxLevel = 4;

$ValueTypes = array('min', 'avg', 'max');

function GetMicrotime()
{
    list($Usec, $Sec) = explode(" ",microtime());
    return ((float)$Usec + (float)$Sec);
}

function MysqlDateTimeToTime($Time)
{
  $Parts = explode(' ', $Time);
  $DateParts = explode('-', $Parts[0]); 
  $TimeParts = explode(':', $Parts[1]);
  $Result = mktime($TimeParts[0], $TimeParts[1], $TimeParts[2], $DateParts[1], $DateParts[2], $DateParts[0]); 
  return($Result);  
}

function TimeToMysqlDateTime($Time)
{
  return(date('Y-m-d H:i:s', $Time));  
}

function TimeSegment($Level)
{
  global $LevelReducing;
  return(pow($LevelReducing, $Level) * 60);
}

function StatTableName($Level)
{
  if($Level == 0) return('stat_data');
    else return('stat_data_cache');
}

function AlignTime($Time, $TimeSegment)
{
  global $ReferenceTime, $LevelReducing;
  return(round(($Time - $ReferenceTime) / $TimeSegment) * $TimeSegment + $ReferenceTime);
}

function GetMeasureById($Id)
{
  global $Database;
  $Result = $Database->select('stat_measure', '*', 'id='.$Id);
  if($Result->num_rows > 0) 
  {
    $Measure = $Result->fetch_array();
    if($Measure['continuity'] == 0) $Measure['ContinuityEnabled'] = 0;  // non continuous
      else $Measure['ContinuityEnabled'] = 2;    // continuous graph  
  } else die('Měřená veličina nenalezena');
  return($Measure); 
}

function AddValue($Measure, $Value)
{
  global $LevelReducing, $MaxLevel, $Database;
  
  $Time = time();
  $Value = round($Measure['divider']*$Value);

  $Result = $Databse->select('stat_data', '*', 'measure='.$Measure['id'].' AND level=0 ORDER BY time DESC LIMIT 2');
  if($Result->num_rows == 0) $Database->insert('stat_data', array('min' => $Value, 'avg' => $Value, 'max' => $Value, 'level' => 0, 'measure' => $Measure['id'], 'time' => TimeToMysqlDateTime($Time),
    'continuity' => 0));
  else if($Result->num_rows == 1) $Database->insert('stat_data', array('min' => $Value, 'avg' => $Value, 'max' => $Value, 'level' => 0, 'measure' => $Measure['id'], 'time' => TimeToMysqlDateTime($Time),
    'continuity' => 1));
  else {
    $LastValue = $Result->fetch_array();
    $NextToLastValue = DB_Row();
    if(($Time - MysqlDateTimeToTime($LastValue['time'])) < 0.75 * $Measure['period']) 
    {
    }
    else 
    {
      if(($Time - MysqlDateTimeToTime($LastValue['time'])) < 1.25 * $Measure['period']) $Continuity = 1; 
        else $Continuity = 0;
      if(($LastValue['avg'] == $NextToLastValue['avg']) and ($LastValue['avg'] == $Value) and 
        ($LastValue['continuity'] == 1) and ($Continuity == 1)) 
      {
        echo('s');
        $Database->update('stat_data', 'time="'.$LastValue['time'].'" AND level=0 AND measure='.$Measure['id'], array('time' => 'NOW()'));
      } else 
      {
        $Database->insert('stat_data', array('min' => $Value, 'avg' => $Value, 'max' => $Value, 'level' => 0, 'measure' => $Measure['id'], 'time' => TimeToMysqlDateTime($Time),
          'continuity' => $Continuity));        
      }
    }
  } 
    
    // Update levels
    //echo($Time."<br>\n");
    for($Level = 1; $Level <= $MaxLevel; $Level++)
    {
      //echo('Level '.$Level."<br>\n");
      $TimeSegment = TimeSegment($Level);
      $EndTime = AlignTime($Time, $TimeSegment);
      //if($EndTime < $Time) $EndTime = $EndTime + $TimeSegment;
      $StartTime = $EndTime - $TimeSegment;
      
      //echo(" ".$TimeSegment." ".$StartTime.'-'.$EndTime."<br>\n");
      //flush();
  
      // Load values in time range
      $Values = array();
      $Result = $Database->select(StatTableName($Level-1), '*', 'time > "'.TimeToMysqlDateTime($StartTime).'" AND time < "'.
        TimeToMysqlDateTime($EndTime).'" AND measure='.$Measure['id'].' AND level='.($Level-1).' ORDER BY time');
      while($Row = $Result->fetch_array())
      {
        $Row['time'] = MysqlDateTimeToTime($Row['time']);
        $Values[] = $Row;
      }
      //print_r($Values);
      //array_pop($Values);      

      // Load subsidary values
      array_unshift($Values, LoadLeftSideValue($Level-1, $Measure, $StartTime));
      array_push($Values, LoadRightSideValue($Level-1, $Measure, $EndTime));

      $Point = ComputeOneValue($StartTime, $EndTime, $Values, $Measure, $Level);
      //print_r($Point);
      
      $Database->delete(StatTableName($Level), '(time > "'.TimeToMysqlDateTime($StartTime).'") AND 
        (time < "'.TimeToMysqlDateTime($EndTime).'") AND measure='.$Measure['id'].' AND level='.$Level);
      $Continuity = $Values[1]['continuity'];   
      $Database->insert(StatTableName($Level), array('level' => $Level, 'measure' => $Measure['id'], 'min' => $Point['min'], 
        'avg' => $Point['avg'], 'max' => $Point['max'], 'continuity' => $Continuity, 'time' => TimeToMysqlDateTime($StartTime+($EndTime-$StartTime)/2)));

    }
}

function Interpolation($X1, $Y1, $X2, $Y2, $X)
{
  $Y = ($Y2 - $Y1) / ($X2 - $X1) * ($X - $X1) + $Y1;
  //echo($Y1.'-'.$Y.'-'.$Y2.' '.$X1.'-'.$X.'-'.$X2.'<br>');
  return($Y);
}

function ComputeOneValue($LeftTime, $RightTime, $Values, $Measure, $Level)
{
  global $ValueTypes;
  
  $NewValue = array('min' => +10000000000, 'avg' => 0, 'max' => -10000000000); 
  
  // Trim outside parts
  foreach($ValueTypes as $ValueType)
  {
    $Values[0][$ValueType] = Interpolation($Values[0]['time'], $Values[0][$ValueType], $Values[1]['time'], $Values[1][$ValueType], $LeftTime);
  }
  $Values[0]['time'] = $LeftTime;
  foreach($ValueTypes as $ValueType)
  {   
    $Values[count($Values)-1][$ValueType] = Interpolation($Values[count($Values)-2]['time'], $Values[count($Values)-2][$ValueType], 
      $Values[count($Values)-1]['time'], $Values[count($Values)-1][$ValueType], $RightTime);
  }
  $Values[count($Values)-1]['time'] = $RightTime;
  
  // Perform computation 
  foreach($ValueTypes as $ValueType)
  { 
    // Compute new value
    for($I = 0; $I < (count($Values) - 1); $I++)
    {      
      if($ValueType == 'avg') 
      {
        if($Values[$I+1]['continuity'] == $Measure['ContinuityEnabled']) ;
          else $NewValue[$ValueType] = $NewValue[$ValueType] + ($Values[$I+1]['time'] - $Values[$I]['time']) *
            (($Values[$I+1][$ValueType] - $Values[$I][$ValueType]) / 2 + $Values[$I][$ValueType]);
      }
      else if($ValueType == 'max') 
      {
        if($Values[$I+1]['continuity'] == $Measure['ContinuityEnabled'])
        {
          if(0 > $NewValue[$ValueType]) $NewValue[$ValueType] = 0;
        }
        else 
        {
          //if($Values[$I][$ValueType] > $NewValue[$ValueType]) $NewValue[$ValueType] = $Values[$I][$ValueType];
          if($Values[$I+1][$ValueType] > $NewValue[$ValueType]) $NewValue[$ValueType] = $Values[$I+1][$ValueType];
        }
      }
      else if($ValueType == 'min') 
      {
        //echo($Values[$I+1]['continuity'].'=='.$Measure['ContinuityEnabled'].'<br>'); 
        if($Values[$I+1]['continuity'] == $Measure['ContinuityEnabled'])
        {
          if(0 < $NewValue[$ValueType]) $NewValue[$ValueType] = 0;
        }
        else 
        {
          //if($Values[$I][$ValueType] < $NewValue[$ValueType]) $NewValue[$ValueType] = $Values[$I][$ValueType];
          if($Values[$I+1][$ValueType] < $NewValue[$ValueType]) $NewValue[$ValueType] = $Values[$I+1][$ValueType];
        }
      }
           
    }  
    $NewValue[$ValueType] = $NewValue[$ValueType]; 
  }
  //if(($RightTime - $LeftTime) > 0) 
  if($Measure['cumulative'] == 0) $NewValue['avg'] = $NewValue['avg'] / ($RightTime - $LeftTime);  
  return($NewValue);
  //echo($NewValue['avg'].'<br>');
  //return(array('min' => rand(0,1), 'avg' => $NewValue['avg'], 'max' => rand(0,1)));
}

function GetTimeRange($Measure, $Level)
{
  global $Debug;
  
  // Get first and last time
  echo($Measure['id'].','.$Level.','.StatTableName($Level)."\n"); 
  $Result = $Database->select(StatTableName($Level), '*', 'measure='.$Measure['id'].' AND level='.$Level.' ORDER BY time LIMIT 1');
  if($Result->num_rows > 0)
  {
    $Row = $Result->fetch_array();
    $AbsoluteLeftTime = MysqlDateTimeToTime($Row['time']);
  } else $AbsoluteLeftTime = 0;

  $Result = $Database->select(StatTableName($Level), '*', 'measure='.$Measure['id'].' AND level='.$Level.' ORDER BY time DESC LIMIT 1');
  if($Result->num_rows > 0)
  {
    $Row = $Result->fetch_array();
    $AbsoluteRightTime = MysqlDateTimeToTime($Row['time']);
  } else $AbsoluteRightTime = 0;

  if($Debug) 
  {
    echo('AbsoluteLeftTime: '.$AbsoluteLeftTime.'('.TimeToMysqlDateTime($AbsoluteLeftTime).')<br>');
    echo('AbsoluteRightTime: '.$AbsoluteRightTime.'('.TimeToMysqlDateTime($AbsoluteRightTime).')<br>');
  }
  return(array('left' => $AbsoluteLeftTime, 'right' => $AbsoluteRightTime));
}

function LoadRightSideValue($Level, $Measure, $Time)
{ 
  global $Debug;
  $Result = array();
  $Result = $Database->select(StatTableName($Level), '*', 'time > "'.TimeToMysqlDateTime($Time).'" AND measure='.$Measure['id'].' AND level='.$Level.' ORDER BY time ASC LIMIT 1');
  if($Result->num_rows > 0) 
  {
    $Row = $Result->fetch_array();
    $Row['time'] = MysqlDateTimeToTime($Row['time']);
    return(array($Row));
  } 
  else 
  {
    //$Time = $Values[count($Values)-1]['time'] + 60;
    //array_push($Values, array('time' => $Time, 'min' => 0, 'avg' => 0, 'max' => 0, 'continuity' => 0));
    $Result[] = array('time' => ($Time + TimeSegment($Level)), 'min' => 0, 'avg' => 0, 'max' => 0, 'continuity' => 0);
    $Result = $Database->select(StatTableName($Level), '*', 'time < "'.TimeToMysqlDateTime($Time).'" AND measure='.$Measure['id'].' AND level='.$Level.' ORDER BY time DESC LIMIT 1');
    if($Result->num_rows > 0)
    {
      $Row = $Result->fetch_array();
      array_unshift($Result, array('time' => (MysqlDateTimeToTime($Row['time'])+10), 'min' => 0, 'avg' => 0, 'max' => 0, 'continuity' => 0)); 
    } 
   // if($Debug) print_r($Result);
    return($Result);
  }
}  

function LoadLeftSideValue($Level, $Measure, $Time)
{
  global $Debug;
  $Result = array();
  //echo('SELECT * FROM '.StatTableName($Level). ' WHERE '. 'time < "'.TimeToMysqlDateTime($Time).'" AND measure='.$Measure['id'].' AND level='.$Level.' ORDER BY time DESC LIMIT 1'."<br>\n");
  $Result = $Database->select(StatTableName($Level), '*', 'time < "'.TimeToMysqlDateTime($Time).'" AND measure='.$Measure['id'].' AND level='.$Level.' ORDER BY time DESC LIMIT 1');
  if($Result->num_rows > 0) 
  {
    $Row = $Result->fetch_array();
    $Row['time'] = MysqlDateTimeToTime($Row['time']);
    return(array($Row));
  }  
  else 
  {
    //$Time = $Values[0]['time'] - 60;
    //array_unshift($Values, array('time' => $Time, 'min' => 0, 'avg' => 0, 'max' => 0, 'continuity' => 0));
    $Result[] = array('time' => ($Time - TimeSegment($Level)), 'min' => 0, 'avg' => 0, 'max' => 0, 'continuity' => 0);
    
    $Result = $Database->select(StatTableName($Level), '*', 'time > "'.TimeToMysqlDateTime($Time).'" AND measure='.$Measure['id'].' AND level='.$Level.' ORDER BY time ASC LIMIT 1');
    if($Result->num_rows > 0)
    {
      $Row = $Result->fetch_array();
      array_push($Result, array('time' => (MysqlDateTimeToTime($Row['time'])-10), 'min' => 0, 'avg' => 0, 'max' => 0, 'continuity' => 0)); 
    } 
//    if($Debug) print_r($Result);
    return($Result);
  }
}

function GetValues($Measure, $TimeFrom, $TimeTo, $Level)
{
  global $DivisionCount, $Debug;
  
  if($Debug) echo('TimeFrom: '.$TimeFrom.'('.TimeToMysqlDateTime($TimeFrom).')<br>');
  if($Debug) echo('TimeTo: '.$TimeTo.'('.TimeToMysqlDateTime($TimeTo).')<br>');

  //$AbsoluteTime = GetTimeRange($MeasureId);
  
//  if(($TimeFrom > $AbsoluteLeftTime) and ($TimeStart < $AbsoluteRightTime) and 
//    ($TimeTo > $AbsoluteLeftTime) and ($TimeTo < $AbsoluteRightTime))
//  {

  // Load values in time range
  $Result = $Database->select(StatTableName($Level), 'time, min, avg, max, continuity', 'time > "'.TimeToMysqlDateTime($TimeFrom).'" AND time < "'.
    TimeToMysqlDateTime($TimeTo).'" AND measure='.$Measure['id'].' AND level='.$Level.' ORDER BY time');
//  echo($Level.' '.TimeToMysqlDateTime($TimeFrom).' '.TimeToMysqlDateTime($TimeTo));
  $Values = array();
//  echo(DB_NumRows());
//  $III = 0;
  while($Row = $Result->fetch_array())
  {
//    echo($III.' '.$Row['time'].' '.memory_get_usage().',');
//    $III++;
    $Values[] = array('time' => MysqlDateTimeToTime($Row['time']), 'min' => $Row['min'], 'avg' => $Row['avg'], 'max' => $Row['max'], 'continuity' => $Row['continuity']);
  }
 // array_pop($Values);
//  echo('abc');
//  die();
  if($Debug) echo('Item count: '.count($Values));
  
  $Points = array();
  if(count($Values) > 0)
  {
    $Values = array_merge(LoadLeftSideValue($Level, $Measure, $TimeFrom), $Values, LoadRightSideValue($Level, $Measure, $TimeTo));
    
    //echo(count($Values).'<br>');
    //echo($TimeFrom.','.$TimeTo.'<br>');
    //echo($Values[0]['time'].'<br>');
    $StartIndex = 0;
    $Points = array();
    for($I = 0; $I < $DivisionCount; $I++)
    {
      $TimeStart = $TimeFrom + (($TimeTo - $TimeFrom) / $DivisionCount) * $I;
      //if($Debug) echo('TimeStart '.$I.': '.$TimeStart.'('.TimeToMysqlDateTime($TimeStart).')<br>');
      $TimeEnd = $TimeFrom + (($TimeTo - $TimeFrom) / $DivisionCount) * ($I+1);
      //if($Debug) echo('TimeEnd '.$I.': '.$TimeEnd.'('.TimeToMysqlDateTime($TimeEnd).')<br>');
      //echo($TimeStart.','.$TimeEnd.'<br>');

      $EndIndex = $StartIndex;
      while($Values[$EndIndex]['time'] < $TimeEnd) $EndIndex = $EndIndex + 1;
      $SubValues = array_slice($Values, $StartIndex, $EndIndex - $StartIndex + 1);
      //echo($StartIndex.','.$EndIndex.' '.count($SubValues).'<br>');
      //print_r($SubValues);
      $Points[] = ComputeOneValue($TimeStart, $TimeEnd, $SubValues, $Measure, $Level);
      $StartIndex = $EndIndex - 1;  
    }
  } else $Points[] = array('min' => 0, 'avg' => 0, 'max' => 0);
  return($Points);
}

function RebuildMeasureCache($Measure)
{
  global $MaxLevel, $LevelReducing;

  echo('Velicina '.$Measure['name']."\n");
  if($Measure['continuity'] == 0) $Measure['ContinuityEnabled'] = 0;  // non continuous
    else $Measure['ContinuityEnabled'] = 2;    // continuous graph

  // Clear previous items
  $Result = $Database->select('stat_data_cache', 'COUNT(*)', 'level>0 AND measure='.$Measure['id']);
  $Row = $Result->fetch_array();
  echo("Mazu starou cache (".$Row[0]." polozek)...");
  $Database->delete('stat_data_cache', 'level>0 AND measure='.$Measure['id']);
  echo("\n");

  for($Level=1; $Level <= $MaxLevel; $Level++)
  {
    echo('Uroven '.$Level."\n");
    $TimeRange = GetTimeRange($Measure, $Level-1);
    //echo($Measure['id'].','.($Level-1)."\n");
    //echo(TimeToMysqlDateTime($TimeRange['left']).'-'.TimeToMysqlDateTime($TimeRange['right'])."\n");
    $TimeSegment = TimeSegment($Level);
    $StartTime = AlignTime($TimeRange['left'], $TimeSegment) - $TimeSegment;
    $EndTime = AlignTime($TimeRange['right'], $TimeSegment);
    $BurstCount = 500; 
    echo('For 0 to '.round(($EndTime - $StartTime) / $TimeSegment / $BurstCount)."\n");
    for($I = 0; $I <= round(($EndTime - $StartTime) / $TimeSegment / $BurstCount); $I++)
    {
      echo($I.' ');
      $StartTime2 = $StartTime + $I * $BurstCount * $TimeSegment;
      $EndTime2 = $StartTime + ($I+1) * $BurstCount * $TimeSegment;
      $Values = array();
      DB_Select(StatTableName($Level-1), '*', 'time > "'.TimeToMysqlDateTime($StartTime2).'" AND time < "'.
        TimeToMysqlDateTime($EndTime2).'" AND measure='.$Measure['id'].' AND level='.($Level-1).' ORDER BY time');
      while($Row = DB_Row())
      {
        $Row['time'] = MysqlDateTimeToTime($Row['time']);
        $Values[] = $Row;
      }
      
      if(count($Values) > 0)
      {        
        $Values = array_merge(LoadLeftSideValue($Level-1, $Measure, $StartTime2), $Values, LoadRightSideValue($Level-1, $Measure, $EndTime2));
 
        $StartIndex = 0;
        for($B = 0; $B < $BurstCount; $B++)
        {          
          echo('.');
          $StartTime3 = $StartTime2 + (($EndTime2 - $StartTime2) / $BurstCount) * $B;
          $EndTime3 = $StartTime2 + (($EndTime2 - $StartTime2) / $BurstCount) * ($B+1);
          
          $EndIndex = $StartIndex;
          while($Values[$EndIndex]['time'] < $EndTime3) $EndIndex = $EndIndex + 1;
          $SubValues = array_slice($Values, $StartIndex, $EndIndex - $StartIndex + 1);
          //echo($StartIndex.','.$EndIndex.' '.count($SubValues).'<br>');
          //print_r($SubValues);
          if(count($SubValues) > 2)
          {        
            $Point = ComputeOneValue($StartTime3, $EndTime3, $SubValues, $Measure, $Level);
            $Continuity = $SubValues[1]['continuity'];   
            DB_Insert(StatTableName($Level), array('level' => $Level, 'measure' => $Measure['id'], 'min' => $Point['min'], 
              'avg' => $Point['avg'], 'max' => $Point['max'], 'continuity' => $Continuity, 'time' => TimeToMysqlDateTime($StartTime3+($EndTime3-$StartTime3)/2)));
          }        
          $StartIndex = $EndIndex - 1;  
        }
      }
      // Load values in time range
      //array_pop($NextValues);
    }  
    echo("Uroven dokoncena\n");         
    DB_Select('stat_data', 'COUNT(*)', 'level='.$Level.' AND measure='.$Measure['id']);
    $Row = DB_Row();
    echo("Vlozeno ".$Row[0]." polozek.\n");
  } 
}   

function RebuildAllMeasuresCache()
{
  global $ReferenceTime, $LevelReducing, $MaxLevel;
  
  
//  echo("Vytvarim novou cache...\n");
    // Load measures
  $Measures = array();
  $Result = $Database->select('stat_measure', '*');
  while($Measures[] = $Result->fetch_array());
  array_pop($Measures);

  foreach($Measures as $Measure)
  {
    RebuildMeasureCache($Measure);  
    echo('Velicina dokoncena<br>');         
  }
}

function InitMeasureDataTable($Measure)
{
  global $Database;
  $Database->query('CREATE TABLE `data_'.$Measure['Name'].'` (
`Time` TIMESTAMP NOT NULL ,
`Avg` '.$Measure['DataType'].' NOT NULL ,
`Continuity` BOOL NOT NULL
) ENGINE = MYISAM ;');

  $Database->query('CREATE TABLE `data_'.$Measure['Name'].'_cache` (
`Time` TIMESTAMP NOT NULL ,
`Level` TINYINT NOT NULL ,
`Min` '.$Measure['DataType'].' NOT NULL ,
`Avg` '.$Measure['DataType'].' NOT NULL ,
`Max` '.$Measure['DataType'].' NOT NULL ,
`Continuity` BOOL NOT NULL
) ENGINE = MYISAM ;');
}

?>
