#!/usr/bin/php
<?php

namespace ADBRimoImport;
use ADBRimoImport\ADBAddressHelper;

//require 'vendor/autoload.php';
require("../../config/config.php");
require("ADBAddressHelper/address_helper.php");

define('FRONKDB_SQLDEBUG',false);
error_reporting(E_ALL & ~(E_NOTICE | E_STRICT | E_DEPRECATED));

require_once(LIBDIR."/mvcfronk/mfRouter/mfRouter.php");
require_once(LIBDIR."/mvcfronk/mfBase/mfBaseModel.php");
require_once(LIBDIR."/mvcfronk/mfBase/mfBaseController.php");

$me = new \User(1);

define("INTERNAL_USER_ID", $me->id);
define("INTERNAL_USER_USERNAME", $me->username);

$mainlog = \mfLoghandler::singleton();
$log = new \mfLog_File();
$log->init(BASEDIR."/var/log/rimo-import.log");

$apiOwner = "estmk";
$apiEdition = "prod";
$apiData = TT_RIMO_API_CREDS[$apiOwner][$apiEdition];

$apiUrl = $apiData["url"];
$apiToken = $apiData["key"];

$epGetClusters = $apiUrl.RIMO_API_JSON_EP_GET_CLUSTERS;
$epGetBuildings = $apiUrl.RIMO_API_JSON_EP_GET_BUILDINGS;
$epGetWorkorders = $apiUrl.RIMO_API_JSON_EP_QUERY_WORKORDERS;
$epGetService = $apiUrl.RIMO_API_JSON_EP_QUERY_SERVICE;

/*
if(!defined("RIMO_API_JSON_APIKEY_PROD")) {
  die("rimo api token not defined!");
}*/

$import_count = 0;

$baseParams = ['apiKey' => $apiToken];

$ctxOptsPost = [
  'http' => [
    'method' => 'POST',
    'header' => 'accept: application/json'
  ]
];

$ctxOptsGet = [
  'http' => [
    'method' => 'GET',
    'header' => 'accept: application/json'
  ]
];

$adb = \FronkDB::singleton(ADDRESSDB_DBHOST, ADDRESSDB_DBUSER, ADDRESSDB_DBPASS, ADDRESSDB_DBNAME);


/*
 * Get RIMO Sales Clusters
 */

$params = $baseParams;
$qs = http_build_query($params);

$req_url = $epGetClusters."?".$qs;
$req_ctx = stream_context_create($ctxOptsGet);

//echo $req_url."\n";
$responseText = file_get_contents($req_url, false, $req_ctx);
if($responseText === false) {
  echo "Error fetching clusters\n";
  exit;
}

$clustersResponse = json_decode($responseText);
//var_dump($clustersResponse);
//exit;
if(!is_object($clustersResponse) || !property_exists($clustersResponse, "item") || !is_array($clustersResponse->item) || !count($clustersResponse->item)) {
  die("Invalid GetClusters Response\n");
}

foreach($clustersResponse->item as $cluster) {
  $cluster_rimo_id = $cluster->id;
  //echo "##################################################\n";
  //echo "$cluster_rimo_id | name: ".$cluster->name."; label: ".$cluster->userLabel."\n";
  //continue;
  $adb_netzgebiet = \ADBNetzgebietModel::getFirst(['rimo_id' => $cluster_rimo_id]);
  if(!$adb_netzgebiet) {
    //echo "Kein Netzgebiet für Salescluster $cluster_rimo_id (".$cluster->name.")\n";
    continue;
  }
  
  
  /*if($cluster_rimo_id != "SDISalesCluster_200193309697_1700559530") {
    // kalwang
    continue;
  }*/
  
  $AddressHelper = new ADBAddressHelper\AddressHelper(["log" => $log, "db" => $adb, "netzgebiet" => $adb_netzgebiet]);

  /*
   * Get Buildings per SalesCluster
   */
  $params = $baseParams;
  $params["clusterId"] = $cluster_rimo_id;
  $qs = http_build_query($params);

  $req_url = $epGetBuildings."?".$qs;
  $req_ctx = stream_context_create($ctxOptsGet);

  //echo $req_url."\n";
  $responseText = file_get_contents($req_url, false, $req_ctx);

  if($responseText === false) {
    echo "Error fetching Buildings in cluster $cluster_rimo_id (".$cluster->name.")\n";
    exit;
  }

  $buildingsResponse = json_decode($responseText);
  
  $hausnummer_count = 0;
  $hausnummer_found_count = 0;
  $homes_count = 0;
  
  if(is_object($buildingsResponse) && property_exists($buildingsResponse, "item") && is_array($buildingsResponse->item) && count($buildingsResponse->item)) {
    foreach($buildingsResponse->item as $building) {
      //var_dump($building);
      if($building->buildingType && $building->buildingType->userLabel != "Greenfield") {
        //var_dump($building);
      } else {
        continue;
      }
      $hausnummer_count++;
      // ignore buildings without units
      if(!$building->plannedTU) {
        continue;
      }
      if($building->buildingType && $building->buildingType->userLabel != "Greenfield" && $building->homesCount > 0 && property_exists($building->homes, "item") && is_array($building->homes->item) && count($building->homes->item)) {
        //print_r($building);exit;
        
        $rimo_building_id = $building->id;
        $hausnummer = $AddressHelper->findUpdateAddressFromRimoBuilding($building);
        if(!$hausnummer) {
          echo "Adresse nicht gefunden: $rimo_building_id\n";
          continue;
        }
        $hausnummer_found_count++;
        
        $rimo_home_count = count($building->homes->item);
        
        $last_unit_num = 0;
        $existing_units = [];
        foreach(\ADBWohneinheitModel::search(["hausnummer_id" => $hausnummer->id]) as $unit) {
          $existing_units[$unit->extref] = $unit;
          if($last_unit_num < $unit->num) {
            $last_unit_num++;
          }
        }
        
        foreach($building->homes->item as $home) {
          //print_r($home);//exit;
          $homes_count++;
          $home_rimo_id = $home->id;
          $home_name = $home->name;
          
          echo "$home_rimo_id\n";
          
          if(array_key_exists($home_rimo_id, $existing_units)) {
            $unit = $existing_units[$home_rimo_id];
          } else {
            // find free home without rimo_id
            $unit = \ADBWohneinheitModel::getFirst(["hausnummer_id" => $hausnummer->id, "extref" => null]);
            echo "-- Using free unit\n";
          }
          
          if(!$unit) {
            // create unit
            $unit = \ADBWohneinheitModel::create([
              "hausnummer_id" => $hausnummer->id,
              "extref" => $home_rimo_id,
              "num" => ++$last_unit_num
            ]);
            if(!$unit->save()) {
              die("Error saving new unit\n".print_r($home, true));
            }
          }
          
          if($unit->extref != $home_rimo_id) {
            $unit->extref = $home_rimo_id;
            if(!$unit->save()) {
              die("Error saving new extref on unit\n".print_r($home, true));
            }
          }
          
          /*
           * TODO: Status based on execution-/operational-state
           */
          
          /*
           *  update FTU data
           */
          $unit_extdata = new \StdClass();
          if($unit->external_data) {
            $extdata = json_decode($unit->external_data);
            
            if(is_object($extdata)) {
              $unit_extdata = $extdata;
            }
          }
          
          if(is_array($home->ftus->item) && $home->ftus->item[0]) {
            //echo "in ftu update\n";
            $ftu_data = new \StdClass();
            $ftu_data->id = $home->ftus->item[0]->id;
            $ftu_data->name = $home->ftus->item[0]->name;

            if(!isset($unit_extdata->rimo)) {
              $unit_extdata->rimo = new \StdClass();
            }
            
            $unit_extdata->rimo->ftu = $ftu_data;
            $unit->external_data = json_encode($unit_extdata);
            if(!$unit->save()) {
              die("!!! Error saving unit extdata\n".print_f($unit));
            }
            
            // check OAID
            if(property_exists($home->ftus->item[0], "oaidObject") && is_object($home->ftus->item[0]->oaidObject) && $home->ftus->item[0]->oaidObject->name) {
              if($home->ftus->item[0]->oaidObject->name != $unit->oaid) {
                if(!$unit->oaid) {
                  // assign oaid to home
                  $rimo_oaid = $home->ftus->item[0]->oaidObject->name;
                  $oaid = \OpenAccessIdModel::getFirst(["oaid" => $rimo_oaid]);
                  if(!$oaid) {
                    echo "!!! Home hat fremde OAID: $rimo_oaid (Home ".$unit->id."\n";
                  } else {
                    $unit->oaid = $rimo_oaid;
                    
                    $oaid->assigned = date("U");
                    $oaid->adb_wohneinheit_id = $unit->id;
                    $oaid->termination_id = null;
                    $oaid->address = $unit->hausnummer->getAddress();
                    $oaid->unit_string = (string)$unit;
                    if(!$oaid->exported) {
                      $oaid->exported = date("U");
                    }
                    
                    if($oaid->export_data) {
                      $exp_data = json_decode($oaid->export_data);
                    } else {
                      $exp_data = new \stdClass();
                    }
                    if(!property_exists($exp_data, "rimo")) {
                      $exp_data->rimo = new \StdClass();
                    }
                    $exp_data->rimo->oaid_id = $home->ftus->item[0]->oaidObject->id;
                    $exp_data->rimo->name = $rimo_oaid;
                    $exp_data->rimo->ftu_id = $ftu_data->id;
                    $exp_data->rimo->ftu_name = $ftu_data->name;
                    $exp_data->rimo->ftu_assigned_date = date("U");
                    
                    $oaid->exported_to = "rmio";
                    $oaid->export_data = json_encode($exp_data);
                    
                    $oaid->save();
                    $unit->save();
                  }
                  
                } else {
                  // 
                }
              }
            }

          }
                      
          // get ports from service
          $params = $baseParams;
          $params["homeId"] = $home_rimo_id;
          $qs = http_build_query($params);
          
          $req_url = $epGetService."?".$qs;
          $req_ctx = stream_context_create($ctxOptsGet);
          
          echo $req_url."\n";
          $responseText = file_get_contents($req_url, false, $req_ctx);
          
          if($responseText === false) {
            echo "Error fetching Service for Home $home_rimo_id\n";
            exit;
          }
          
          $serviceResponse = json_decode($responseText);
          
          if(is_object($serviceResponse) && property_exists($serviceResponse, "item") && is_array($serviceResponse->item) && count($serviceResponse->item)) {
            foreach($serviceResponse->item as $service) {
              if($service->masterItem->name != "FTTx Service (red)") continue;
              if(!is_object($service->portA) || !$service->portA) continue;
              
              $fixedDN = $service->portA->fixEndDN;

              if($fixedDN) {
                echo "fixedDn found: $fixedDN\n";
                $dn = getServiceDnValues($fixedDN);
                if(array_key_exists("Shelf", $dn) && array_key_exists("PatchPanel", $dn) && array_key_exists("Port", $dn)) {
                  $cluster = null;
                  if(array_key_exists("SDICluster", $dn)) {
                    $cluster = $dn['SDICluster'];
                  }
                  $shelf = $dn['Shelf'];
                  $patchpanel = $dn['PatchPanel'];
                  $port = $dn['Port'];

                  if($cluster) {
                    $unit->patch_cluster = $cluster;
                    $unit->save();
                  }
                  if($shelf) {
                    $unit->patch_shelf = $shelf;
                    $unit->save();
                  }
                  if($patchpanel) {
                    $unit->patch_module = $patchpanel;
                    $unit->save();
                  }
                  if($port) { 
                    $unit->patch_port = $port;
                    $unit->save();
                  }
                }
              }
            }
          }
          
          
        }
        
        // get workorders
        $params = $baseParams;
        $params["buildingId"] = $rimo_building_id;
        $qs = http_build_query($params);
        
        $req_url = $epGetWorkorders."?".$qs;
        $req_ctx = stream_context_create($ctxOptsGet);
        
        echo $req_url."\n";
        $responseText = file_get_contents($req_url, false, $req_ctx);
        
        if($responseText === false) {
          echo "Error fetching Workorders for building $rimo_building_id\n";
          exit;
        }

        $workordersResponse = json_decode($responseText);
        
        //print_r($workordersResponse);exit;
        
        if(is_object($workordersResponse) && property_exists($workordersResponse, "item") && is_array($workordersResponse->item) && count($workordersResponse->item)) {
          foreach($workordersResponse->item as $workorder) {
            $rimo_workorder_id = $workorder->id;
            $rimo_workorder_name = $workorder->name;
            $workorder_status = $workorder->state->userLabel;
            $workorder_home_id = $workorder->home->id;
            
            $wo = \RimoWorkorderModel::getFirst(["rimo_id" => $rimo_workorder_id]);
            
            if($wo && $workorder_status != $wo->rimo_status) {
              echo "Updating Workorder $rimo_workorder_id ($workorder_home_id)\n";
              $wo->rimo_status = $workorder_status;
              $wo->save();
            }
            
            if(!$wo) {
              $wo_home = \ADBWohneinheitModel::getFirst(["extref" => $workorder_home_id]);
              
              if(!$wo_home) {
                echo "Home zu Workorder $rimo_workorder_id ($workorder_home_id) nicht gefunden\n";
                continue;
              }
              
              echo "Creating Workorder $rimo_workorder_id ($workorder_home_id)\n";
              $wo = \RimoWorkorderModel::create([
                "adb_wohneinheit_id" => $wo_home->id,
                "rimo_id" => $rimo_workorder_id,
                "rimo_name" => $rimo_workorder_name,
                "rimo_status" => $workorder_status
              ]);
              if(!$wo->save()) {
                echo "Fehler beim Erstellen der RimoWorkorder $rimo_workorder_id ($workorder_home_id)\n";
              }
            }
          }
        }
        
        
        //exit;
      }
      
    }
    echo "Cluster $cluster->name: $hausnummer_count Buildings; $hausnummer_found_count Buildings verarbeitet; $homes_count Homes verarbeitet.\n";
  }
}

//echo $response;
echo "\n";

function getServiceDnValues($dn) {
  $dn = explode(":", $dn);
  $fields = [];

  foreach($dn as $d) {
    $m = [];
    if(preg_match('/^([^{]+)\{([^}]+)\}$/',$d, $m)) {
      if(!$m[1] || !$m[2]) {
        continue;
      }
      $value = $m[1];
      $key = $m[2];

      if(array_key_exists($key, $fields)) {
        if(is_array($fields[$key])) {
          $fields[$key][] = $value;
        } else {
          $tmp = $fields[$key];
          $fields[$key] = [];
          $fields[$key][] = $tmp;
          $fields[$key][] = $value;
        }
      } else {
        $fields[$key] = $value;
      }
    }
  }

  if(array_key_exists("Shelf", $fields) && is_array($fields['Shelf'])) {
    $shelf = implode(" ", $fields['Shelf']);
    $fields['Shelf'] = $shelf;
  }

  if(!array_key_exists("PatchPanel", $fields) && array_key_exists("Shelf", $fields)) {
    $m = [];
    if(preg_match('/^([MB]\d[^ ]*)\s+([MB]\d[^ ]*)/i', $fields['Shelf'], $m)) {
      foreach([1,2] as $i) {
        if(strlen($m[$i])) {
          $letter = substr(strtoupper($m[$i]), 0, 1);
          if($letter == "B") {
            $fields['Shelf'] = $m[$i];
          }
          if($letter == "M") {
            $fields['PatchPanel'] = $m[$i];
          }
        }
      }
    }
  }

  return $fields;
}