<?php

class AddressDBController extends mfBaseController {

  protected function init() {
    $this->needlogin=true;
    $me = new User();
    $me->loadMe();
    $this->me = $me;
    $this->layout()->set("me",$me);
    
    if(!$me->is(["Admin", "netowner"]) && !$me->can("Preorder")) {
      $this->redirect("Dashboard");
    }
  }

  
  protected function indexAction() {
    $this->layout()->setTemplate("AddressDB/Index");
    
    if($this->request->resetFilter) {
      unset($_SESSION[MFAPPNAME.'-AddressDB-filter']);
    }
    
    $filter = [];
    if(is_array($this->request->filter)) {
      $filter = $this->request->filter;
      $_SESSION[MFAPPNAME.'-AddressDB-filter'] = $filter;
    } else {
      if(array_key_exists(MFAPPNAME.'-AddressDB-filter', $_SESSION) && count($_SESSION[MFAPPNAME.'-AddressDB-filter'])) {
        $filter = $_SESSION[MFAPPNAME.'-AddressDB-filter'];
      }
    }
    
    $this->layout->set("filter", $filter);

    if($this->me->is("Admin") && $this->request->submitBulkUpdate) {
        return $this->saveBulkupdateAction();
    }


    $filter = $this->getPreparedFilter($filter);

    // pagination defaults
    $pagination = [];
    $pagination['start'] = 0;
    $pagination['count'] = 25;
    $pagination['maxItems'] = 0;
    
    if(is_numeric($this->request->s)) {
      $pagination['start'] = intval($this->request->s);
    }
    
    
    if($this->me->is("Admin")) {
      $my_networks = NetworkModel::getAll();
      if(array_key_exists("network_id", $filter) && $filter['network_id']) {
        $filter['netzgebiet_id'] = $filter['network_id'];
      }
    } else {
      $my_networks = $this->me->myNetworks(["netowner", "salespartner"]);
    }

    $netzgebiet_ids = [];
    $my_adb_networks = [];
    foreach($my_networks as $network) {
      if($network->adb_netzgebiet_id && !in_array($network->adb_netzgebiet_id, $netzgebiet_ids)) {
        $netzgebiet_ids[] = $network->adb_netzgebiet_id;

        $adb_network = new ADBNetzgebiet($network->adb_netzgebiet_id);
        if(!$adb_network->isLoaded()) continue;
        $my_adb_networks[$network->adb_netzgebiet_id] = $adb_network;
      }
    }
    //var_dump($my_networks, $my_adb_networks);
    if(!$this->me->is("Admin") && array_key_exists("network_id", $filter)) {
      if(array_key_exists($filter['network_id'], $my_adb_networks)) {
        $filter['netzgebiet_id'] = $filter['network_id'];
      } else {
        unset($filter['network_id']);
      }
      
    }
    
    $addressdb_filter = $filter;
    if(!array_key_exists("netzgebiet_id", $addressdb_filter)) {
      $addressdb_filter['netzgebiet_id'] = $netzgebiet_ids;
    }

    $this->layout()->set("my_networks", ADBNetzgebietModel::getAll());
    $this->layout()->set("my_adb_networks", $my_adb_networks);
    
    if(array_key_exists("netzgebiet_id", $filter) && $filter['netzgebiet_id'] === "null") {
      $addressdb_filter['netzgebiet_id'] = 0;
      $pagination['maxItems'] = ADBHausnummerModel::count($addressdb_filter, true);
      $addresses = ADBHausnummerModel::search($addressdb_filter, $pagination);
    } else if(count($my_adb_networks)) {
      $pagination['maxItems'] = ADBHausnummerModel::count($addressdb_filter, true);
      $addresses = ADBHausnummerModel::search($addressdb_filter, $pagination);
    }
    $this->layout()->set("pagination", $pagination);
    $this->layout()->set("addresses", $addresses);
    
    // get filter lists
    $filter_filter = [];
    if(array_key_exists("netzgebiet_id", $addressdb_filter)) {
      $filter_filter["netzgebiet_id"] = $netzgebiet_ids;
      $this->layout()->set("gemeinden", ADBGemeindeModel::search($filter_filter));
      if(array_key_exists("gemeinde_id", $addressdb_filter)) {
        $filter_filter['gemeinde_id'] = $addressdb_filter['gemeinde_id'];
      }
      $this->layout()->set("ortschaften", ADBOrtschaftModel::search($filter_filter));
    }

    if($this->request->rimoAddressUpdate) {
        $this->updateAddressesInRimo(ADBHausnummerModel::search($addressdb_filter));
        unset($filter["rimoAddressUpdate"]);
        $qs = http_build_query($filter);
        $this->redirect("AddressDB", "index", $filter);
    }
    
  }
  
  protected function getPreparedFilter($filter) {
    $new_filter = [];
    
    if(array_key_exists("street", $filter) && $filter['street']) {
      $new_filter['strasse%'] = "%".$filter['street'];
      unset($filter['street']);
    }
    
    if(array_key_exists("hausnummer", $filter) && $filter['hausnummer']) {
      $new_filter['hausnummer%'] = $filter['hausnummer'];
      unset($filter['hausnummer']);
    }
    
    if(array_key_exists("adrcd", $filter) && $filter['adrcd']) {
      $new_filter['adrcd%'] = $filter['adrcd'];
      unset($filter['adrcd']);
    }
    
    if(array_key_exists("oaid", $filter) && $filter['oaid']) {
      $new_filter['oaid%'] = "%".$filter['oaid'];
      unset($filter['oaid']);
    }
    
    if(array_key_exists("extref", $filter) && $filter['extref']) {
      $new_filter['extref%'] = "%".$filter['extref'];
      unset($filter['extref']);
    }

      if(array_key_exists("rimo_id", $filter) && $filter['rimo_id']) {
          $new_filter['rimo_id%'] = $filter['rimo_id'];
          unset($filter['rimo_id']);
      }
    
    if(array_key_exists("zip", $filter) && $filter['zip']) {
      $new_filter['plz%'] = $filter['zip'];
      unset($filter['zip']);
    }
    
    if(array_key_exists("rollout", $filter) && $filter['rollout']) {
      $new_filter['rollout%'] = $filter['rollout'];
      unset($filter['rollout']);
    }
    
    if(array_key_exists("rollout_info", $filter) && $filter['rollout_info']) {
      $new_filter['rollout_info%'] = $filter['rollout_info'];
      unset($filter['rollout_info']);
    }
    
    if(array_key_exists("gemeinde", $filter) && $filter['gemeinde']) {
      $new_filter['gemeinde%'] = $filter['gemeinde'];
      unset($filter['gemeinde']);
      unset($filter['gemeinde_id']);
    }
    
    if(array_key_exists("ortschaft", $filter) && $filter['ortschaft']) {
      $new_filter['ortschaft%'] = $filter['ortschaft'];
      unset($filter['ortschaft']);
      unset($filter['ortschaft_id']);
    }

    if(array_key_exists("visibility", $filter) && $filter['visibility']) {
      $new_filter['visibility'] = $filter['visibility'];
    } else {
      $new_filter["visibility"] = ["public", "private"];
      unset($filter['visibility']);
    }

      if(array_key_exists("status_id", $filter)) {
          if(is_array($filter["status_id"])) {
              $new_filter["status_id"] = $filter["status_id"];
          }
          unset($filter["status_id"]);
      }

      if(array_key_exists("status_flag", $filter)) {
          if(is_array($filter["status_flag"])) {
              $new_filter["status_flag"] = $filter["status_flag"];
          }
          unset($filter["status_flag"]);
      }

      if(array_key_exists("network_id", $filter)) {
          if(is_array($filter["network_id"])) {
              $new_filter["netzgebiet_id"] = $filter["network_id"];
          }
          unset($filter["network_id"]);
      }
    
    if(is_array($filter) && count($filter)) {
        foreach($filter as $name => $value) {
            if (is_array($value) && count($value)) $new_filter[$name] = $value;
            else if(strlen($value) > 0) $new_filter[$name] = $value;
      }
    }
    
    return $new_filter;
  }

  private function updateAddressesInRimo($addresses) {
      foreach($addresses as $address) {
          $address->updateAddressInRimo();
      }
      $this->layout()->setFlash(count($addresses)." Adressen in Rimo aktualisiert", "success");
  }
  
  protected function viewAction() {
    $this->layout()->setTemplate("AddressDB/View");
    
    $id = $this->request->id;
    if(!is_numeric($id) || $id < 1) {
      $this->layout()->setFlash("Adresse nicht gefunden", "error");
      $this->redirect("AddressDB");
    }
    
    $hausnummer = new ADBHausnummer($id);
    if(!$hausnummer->id) {
      $this->layout()->setFlash("Adresse nicht gefunden", "error");
      $this->redirect("AddressDB");
    }
    
    /*if(!in_array($hausnummer->netzgebiet_id, $my_adb_networks)) {
      $this->layout()->setFlash("Adresse nicht gefunden", "error");
      $this->redirect("AddressDB");
    }*/
    
    $this->layout()->set("address", $hausnummer);
  }
  
  protected function addAction() {
    $this->layout()->setTemplate("AddressDB/Form");
    
    if($this->me->is("Admin")) {
      $my_networks = NetworkModel::getAll();
    } else {
      $my_networks = $this->me->myNetworks(["netowner", "salespartner"]);
    }

    $netzgebiet_ids = [];
    $my_adb_networks = [];
    foreach($my_networks as $network) {
      if($network->adb_netzgebiet_id && !in_array($network->adb_netzgebiet_id, $netzgebiet_ids)) {
        $netzgebiet_ids[] = $network->adb_netzgebiet_id;

        $adb_network = new ADBNetzgebiet($network->adb_netzgebiet_id);
        if(!$adb_network->isLoaded()) continue;
        $my_adb_networks[$network->adb_netzgebiet_id] = $adb_network;
      }
    }
    $this->layout()->set("my_adb_networks", $my_adb_networks);
    
    
    $save_data = [];
    foreach($this->request->get() as $key => $value) {
      $save_data[$key] = $value;
    }
    //var_dump($save_data);exit;
    $this->layout()->set("save_data", $save_data);
    
  }
  
  protected function editAction() {
    $id = $this->request->id;
    if(!is_numeric($id) || $id < 1) {
      $this->layout()->setFlash("Adresse nicht gefunden", "error");
      $this->redirect("AddressDB");
    }
    
    $hausnummer = new ADBHausnummer($id);
    if(!$hausnummer->id) {
      $this->layout()->setFlash("Adresse nicht gefunden", "error");
      $this->redirect("AddressDB");
    }
    
    /*if(!in_array($hausnummer->netzgebiet_id, $my_adb_networks)) {
      $this->layout()->setFlash("Adresse nicht gefunden", "error");
      $this->redirect("AddressDB");
    }*/
    
    $this->layout()->set("address", $hausnummer);
    
    return $this->addAction();
  }
  
  protected function saveAction() {
    $r = $this->request;
    $id = $r->id;
    //var_dump($r->get());exit;
    
    $address_data = [];
    
    if(is_numeric($id) && $id > 0) {
      $mode = "edit";
      $hausnummer = new ADBHausnummer($id);
      if(!$hausnummer->id) {
        $this->layout()->setFlash("Addresse nicht gefunden", "error");
        $this->redirect("AddressDB");
      }
      $address_data['hausnummer_id'] = $hausnummer->id;
    } else {
      $mode = "add";
    }
    
    $required = ['strasse','hausnummer','plz','ortschaft','gemeinde'];
    if(!$this->me->is("Admin")) {
      $required[] = "netzgebiet_id";
    }
    foreach(['adrcd','extref','rimo_id','netzgebiet_id','strasse','hausnummer','stiege','plz','ortschaft','gemeinde','grund_nr','gdaeigenschaft','meridian','rw','hw','gps_lat','gps_long','unit_count','visibility','tool_building_type', 'tool_building_type_override'] as $field) {
      if(in_array($field, $required)) {
        if(!trim($r->$field)) {
          $this->layout()->setFlash("'".ucfirst($field)."' darf nicht leer sein!", "error");
          return $this->addAction();
        }
      }
      $address_data[$field] = $this->db()->escape(trim($r->$field));
    }
    
    $gemeinde = ADBGemeindeModel::getFirst(['name' => $address_data['gemeinde']]);
    if(!$gemeinde->id) {
      $this->layout()->setFlash("Gemeinde nicht gefunden", "error");
      return $this->addAction();
      //$this->redirect("AddressDB", $mode, ['id' => $id]);
    }
    
    $address_data['gemeinde_id'] = $gemeinde->id;
    
    $freigabe = [];
    if(is_array($r->freigabe) && count($r->freigabe)) {
      if(in_array("interest", $r->freigabe)) {
        $freigabe[] = "interest";
      }
      if(in_array("provision", $r->freigabe)) {
        $freigabe[] = "provision";
      }
      if(in_array("order", $r->freigabe)) {
        $freigabe[] = "order";
      }
      if(in_array("reorder", $r->freigabe)) {
        $freigabe[] = "reorder";
      }
      
    }
    
    $address_data['freigabe'] = $freigabe;
    
    $rollout = null;
    $rollout_info = null;
    if(trim($r->rollout)) {
      $rollout = intval(trim($r->rollout));
    }
    if(trim($r->rollout_info)) {
      $rollout_info = trim($r->rollout_info);
    }
    if(!$rollout && !$rollout_info) {
      $rollout_info = "unscheduled";
    }
    
    $address_data['rollout'] = $rollout;
    $address_data['rollout_info'] = $rollout_info;
    
    //var_dump($address_data);exit;
    
    $adb = new AddressDB();
    $hausnummer_id = $adb->createUpdateHausnummer($address_data);
    if(is_array($adb->validation_error) && count($adb->validation_error)) {
      $this->layout()->setFlash(implode("<br />\n",$adb->validation_error), "warning");
    }
    if(!$hausnummer_id) {
      $this->layout()->setFlash("Fehler beim Erstellen der Adresse!", "error");
      return $this->addAction();
      //$this->redirect("AddressDB");
    }
    
    
    /*
     * Wohneinheiten erstellen
     */
    if(is_numeric($r->unit_count) && $r->unit_count) {
      $unit_count = $r->unit_count;
      $hausnummer = new ADBHausnummer($hausnummer_id);
      $existing_units_count = ADBWohneinheitModel::count(['hausnummer_id' => $hausnummer->id]);
      //var_dump($hausnummer,$existing_units_count);exit;
      if($existing_units_count < $unit_count) {
        $new_units_count = $unit_count - $existing_units_count;
        $last_unit_num = 0;

        foreach(ADBWohneinheitModel::search(['hausnummer_id' => $hausnummer->id]) as $tmp_unit) {
          if($tmp_unit->num > $last_unit_num) {
            $last_unit_num = $tmp_unit->num;
          }
        }

        // create wohneinheiten
        for($i = 1; $i <= $new_units_count; $i++) {
          $num = $last_unit_num + $i;
          //echo "$existing_units_count create wohneinheit $num\n";
          $unit_data = [
            'hausnummer_id' => $hausnummer->id,
            'num' => $num,
          ];
          $wohneinheit = ADBWohneinheitModel::create($unit_data);
          $wohneinheit_id = $wohneinheit->save();
          if(!$wohneinheit_id) {
            $this->layout()->setFlash("Fehler beim Erstellen einer Wohneinheit!", "warning");
            return $this->addAction();
          }
          if($hausnummer->netzgebiet->unit_create_oaid) {
            $wohneinheit->oaid = $wohneinheit->getNewOAID();
          }
          $wohneinheit->save();
          $w++;
        }

      }
    }
    
    //$qs = http_build_query(['filter' => ['oaid' => $hausnummer->oaid]]);
    //var_dump($qs);exit;
    $this->layout()->setFlash("Adresse erfolgreich gespeichert", "success");
    $this->redirect("AddressDB");
    
  }

  protected function deleteAction() {
      $id = $this->request->id;
      if(!is_numeric($id) || $id < 1) {
          $this->layout()->setFlash("Adresse nicht gefunden", "error");
          $this->redirect("AddressDB");
      }

      $hausnummer = new ADBHausnummer($id);
      if(!$hausnummer->id) {
          $this->layout()->setFlash("Adresse nicht gefunden", "error");
          $this->redirect("AddressDB");
      }

      foreach($hausnummer->wohneinheiten as $unit) {
          if(PreorderModel::count(["adb_wohneinheit_id" => $unit->id])) {
              $this->layout()->setFlash("Adresse kann nicht gelöscht werden, da Wohneinheiten in Verwendung sind", "error");
              $this->redirect("AddressDB");
          }

          $oaid = OpenAccessIdModel::getFirstOaid($unit->oaid);
          if($oaid && $oaid->origin == "ofaa") {
              $this->layout()->setFlash("Adresse kann nicht gelöscht werden, da Wohneinheiten mit vergebenen OFAA OAIDs vorhanden sind", "error");
              $this->redirect("AddressDB");
          }
      }

      foreach($hausnummer->wohneinheiten as $unit) {
          // delete workorders
          foreach(RimoWorkorderModel::search(["adb_wohneinheit_id" => $unit->id]) as $wo) {
              $wo->delete();
          }
      }

      $hausnummer->delete();

      $this->layout()->setFlash("Adresse erfolgreich gelöscht", "success");
      $this->redirect("AddressDB");
  }

  protected function exportAction() {
      return $this->exportAddressdb();
  }

  protected function exportHomesAction() {
      return $this->exportAddressdb(true);
  }
  private function exportAddressdb($export_homes = false) {
    $rfilter = $this->request->filter;
    if(!is_array($rfilter)) {
      $rfilter = [];
    }
    $filter = $this->getPreparedFilter($rfilter);
    
    
    if($this->me->is("Admin")) {
      $my_networks = NetworkModel::getAll();
    } else {
      $my_networks = $this->me->myNetworks(["netowner", "salespartner"]);
    }

    $netzgebiet_ids = [];
    $my_adb_networks = [];
    foreach($my_networks as $network) {
      if($network->adb_netzgebiet_id && !in_array($network->adb_netzgebiet_id, $netzgebiet_ids)) {
        $netzgebiet_ids[] = $network->adb_netzgebiet_id;

        $adb_network = new ADBNetzgebiet($network->adb_netzgebiet_id);
        if(!$adb_network->isLoaded()) continue;
        $my_adb_networks[$network->adb_netzgebiet_id] = $adb_network;
      }
    }
    
    if(array_key_exists("network_id", $filter) && $filter['network_id']) {
      if($this->me->is("Admin")) {
        $filter['netzgebiet_id'] = $filter['network_id'];
      } else {
        if(in_array($filter['network_id'], $netzgebiet_ids)) {
          $filter['netzgebiet_id'] = $filter['network_id'];
        }
      }
    }
    unset($filter['network_id']);
    
    $addressdb_filter = $filter;
    if(!array_key_exists("netzgebiet_id", $addressdb_filter)) {
      $addressdb_filter['netzgebiet_id'] = $netzgebiet_ids;
    }
    
    // Get mysqli resource from Model so layout can output data as it's retrieved
    // Fixes lousy performance and horrendous memory usage
    $res = ADBHausnummerModel::search($addressdb_filter, [], true);

    if($export_homes) {
        $this->layout()->setTemplate("AddressDB/export_homes.csv");
    } else {
        $this->layout()->setTemplate("AddressDB/export.csv");
    }

    $this->layout()->set("res", $res);
    
    //var_dump($filter, $hausnummern);exit;
    
    
  }


  protected function updateVisibilityExternalIdAction() {
      $this->layout()->setTemplate("AddressDB/ExternalIdVisivilityUpdate");
  }

  protected function saveVisibilityExternalIdAction() {
      $headline_included = $this->request->headline;

      if(is_array($_FILES) && array_key_exists("visibilityupdate_csv", $_FILES) && !$_FILES['visibilityupdate_csv']['error']) {
          // look for uploaded import file
          try {
              // returns File object or throws Exception on error
              $file = mfUpload::handleFormUpload("visibilityupdate_csv");
          } catch(Exception $ex) {
              $this->layout()->setFlash("Fehler beim Dateiupload: " . $ex->getMessage(), "error");
              $this->redirect("AddressDB", "updateVisibilityExternalId");
          }

          $i = 0;
          $forbidden = 0;
          $notfound = 0;
          $nochange = 0;
          $saved = 0;

          $filename = $file->getFullPath();
          $input = fopen($filename, "r");
          while($csv = fgetcsv($input, 0, ";")) {
              $i++;
              if($i == 1 && $headline_included) continue;

              if(!trim($csv[0])) {
                  continue;
              }

              $id = trim($csv[0]);
              $visibility = trim($csv[1]);
              $rimo_id = trim($csv[2]);

              $address = new ADBHausnummer($id);
              if(!$address) {
                  $notfound++;
                  continue;
              }

              $allowed_network = false;
              foreach($this->me->myNetworks(["netowner", "salespartner"]) as $my_network) {
                  if($my_network->adb_netzgebiet_id == $address->netzgebiet_id) {
                      $allowed_network = true;
                      break;
                  }
              }
              if(!$allowed_network) {
                  $forbidden++;
                  continue;
              }

              if($address->rimo_id != $rimo_id || $address->visibility != $visibility) {

                  if($address->rimo_id != $rimo_id) {
                      // find if rimo id is in use already
                      $test_rimo_id = ADBHausnummerModel::search(["rimo_id" => $rimo_id]);
                      foreach($test_rimo_id as $test_address) {
                          if($test_address && $test_address->id != $address->id) {
                              $test_address->rimo_id = null;
                              $test_address->save();
                          }
                      }


                  }

                  $address->rimo_id = $rimo_id;
                  $address->visibility = $visibility;
                  $address->save();
                  $saved++;
              } else {
                  $nochange++;
              }

          }

          $message = "Import erfolgreich. $saved/$i Adressen updated.";
          if($notfound) {
              $message .= "<br />$notfound Adressen nicht gefunden";
          }
          if($forbidden) {
              $message .= "<br />$forbidden Adressen in falschem Netzgebiet";
          }
          if($nochange) {
              $message .= "<br />$nochange Adressen ohne Änderung";
          }
          $this->layout()->setFlash($message, "success");
          $this->redirect("AddressDB", "updateVisibilityExternalId");

      } else {
          $this->layout()->setFlash("Nichts importiert!", "info");
          $this->redirect("AddressDB", "updateVisibilityExternalId");
      }
  }

    /*protected function statusUpdateimportAction() {
        $this->layout()->setTemplate("AddressDB/Statusupdateimport");
    }*/

    /*protected function saveStatusupdateImportAction() {
        $headline_included = $this->request->headline;

        if(is_array($_FILES) && array_key_exists("statusupdate_csv", $_FILES) && !$_FILES['statusupdate_csv']['error']) {
            // look for uploaded import file
            try {
                // returns File object or throws Exception on error
                $file = mfUpload::handleFormUpload("statusupdate_csv");
            } catch(Exception $ex) {
                $this->layout()->setFlash("Fehler beim Dateiupload: " . $ex->getMessage(), "error");
                $this->redirect("Preorder", "statusupdateimport");
            }

            $i = 0;
            $forbidden = 0;
            $notfound = 0;
            $invalidcode = 0;
            $nochange = 0;
            $saved = 0;
            $flags_saved = 0;

            $statusflags = [];

            $filename = $file->getFullPath();
            $input = fopen($filename, "r");
            while($csv = fgetcsv($input, 0, ";")) {
                $i++;

                if($i == 1 && $headline_included) {
                    // get statusflag order in header
                    $col = 2;
                    while(array_key_exists($col, $csv) && trim($csv[$col])) {
                        $code = trim($csv[$col]);
                        if(!is_numeric($code)) {
                            $this->layout()->setFlash("Ungültige Überschrift für Spalte ".++$col, "error");
                            $this->redirect("Preorder", "statusupdateimport");
                        }

                        $sflag = PreorderStatusflagModel::getFirst(["code" => $code]);
                        if(!$sflag) {
                            $this->layout()->setFlash("Statusflag mit Code $code nicht gefunden", "error");
                            $this->redirect("Preorder", "statusupdateimport");
                        }
                        $sflag->col = $col;
                        $statusflags[$code] = $sflag;
                        $col++;
                    }
                    continue;
                }

                if(!trim($csv[0])) {
                    continue;
                }

                $oaid = trim($csv[0]);
                $new_status_code = trim($csv[1]);

                $preorder = PreorderModel::getFirstActive(["oaid" => $oaid]);
                if(!$preorder) {
                    $notfound++;
                    continue;
                }

                if($preorder->campaign->network->owner_id != $this->me->address_id) {
                    $forbidden++;
                    continue;
                }

                if($preorder->status->code != $new_status_code) {
                    $new_status = PreorderstatusModel::getFirst(["code" => $new_status_code]);
                    if(!$new_status_code) {
                        $invalidcode++;
                        continue;
                    }
                    $preorder->status_id = $new_status->id;
                    $preorder->save();
                    $preorder->resetSaveNesting();
                    $saved++;
                } else {
                    $nochange++;
                }

                if(count($statusflags)) {
                    foreach($statusflags as $code => $origin_sflag) {
                        $this->log->debug(__METHOD__.": $oaid - testing flag $code for update.");
                        $sflag = clone($origin_sflag);
                        $sflag->preorder_id = $preorder->id;

                        if(!$sflag->col) {
                            $this->layout()->setFlash("Kann Statusflagcode $code nicht zuordnen. Line $i col ".$sflag->col, "error");
                            $this->redirect("Preorder", "statusupdateimport");
                        }

                        if(!array_key_exists($sflag->col, $csv)) {
                            $this->log->debug(__METHOD__.": no col.");
                            continue;
                        }

                        $value = trim($csv[$sflag->col]);
                        if(!strlen($value)) {
                            $this->log->debug(__METHOD__.": no val");
                            continue;
                        }

                        if($value) {
                            $sflag->value->value = 1;
                        } else {
                            $sflag->value->value = 0;
                        }

                        $this->log->debug(__METHOD__.": $oaid - saving flag value $code value: ".$sflag->value->value." ($value)");
                        $sflag->value->save();

                        $flags_saved++;
                        //$this->log->debug(__METHOD__.": $oaid - loading preorder again");
                    }

                    $preorder = PreorderModel::getFirstActive(["oaid" => $oaid]);
                    $preorder->resetSaveNesting();
                    $preorder->afterSave();
                    $preorder = PreorderModel::getFirstActive(["oaid" => $oaid]);
                    $preorder->resetSaveNesting();
                }

            }

            $message = "Import erfolgreich. $saved Statusupdates importiert";
            if($flags_saved) {
                $message .= "<br />$flags_saved Statusflags upgedatet";
            }
            if($notfound) {
                $message .= "<br />$notfound Bestellungen nicht gefunden";
            }
            if($forbidden) {
                $message .= "<br />$forbidden Bestellungen in falschem Netzgebiet";
            }
            /*if($nochange) {
                $message .= "<br />$nochange Bestelllungen haben bereits den neuen Status";
            }*//*
            if($invalidcode) {
                $message .= "<br />$invalidcode ungültige Statuscodes";
            }
            $this->layout()->setFlash($message);
            $this->redirect("Preorder", "statusupdateimport");

        } else {
            $this->layout()->setFlash("Nichts importiert!", "info");
            $this->redirect("Preorder", "statusupdateimport");
        }
    }*/

    protected function syncAddressToRimoAction() {
        if(!$this->me->is("Admin")) {
            $this->redirect("AddressDB");
        }

        $hausnummer_id = $this->request->id;
        if(!$hausnummer_id) {
            $this->layout()->setFlash("Adresse nicht gefunden", "error");
            $this->redirect("AddressDB");
        }

        $hausnummer = new ADBHausnummer($hausnummer_id);
        if(!$hausnummer->id) {
            $this->layout()->setFlash("Adresse nicht gefunden", "error");
        }

        if(!$hausnummer->updateAddressInRimo()) {
            $this->layout()->setFlash("Fehler beim updaten der Adresse in Rimo", "error");
            $this->redirect("AddressDB");
        }

        $this->layout()->setFlash("Adresse erfolgreich nach Rimo synchronisiert", "success");
        $this->redirect("AddressDB");

    }

    protected function saveBulkupdateAction() {
        if(!$this->me->is("Admin")) {
            $this->redirect("AddressDB");
        }

        if(!$this->request->filter) {
            $this->layout()->setFlas("Filter erforderlich!");
            $this->redirect("AddressDB");
        }

        $filter = $this->getPreparedFilter($this->request->filter);
        $filter["netzgebiet_id"] = true;

        //var_dump($this->request->get(), $filter);exit;

        $update = [];

        $ort_search = trim($this->request->ort);
        $gemeinde_search = trim($this->request->gemeinde);
        $plz_search = trim($this->request->plz);
        $strasse_search = trim($this->request->strasse);

        $do_rimo_update = $this->request->request_rimo_update;

        $i = 0;
        $u = 0;

        if(ADBHausnummerModel::count($filter, true) > 1000) {
            $this->layout()->setFlash("Bissi viel auf einmal");
        }

        $cache = [];
        $cache["gemeinde"] = [];
        $cache["ort"] = [];
        $cache["plz"] = [];
        $cache["strasse"] = [];

        foreach(ADBHausnummerModel::search($filter) as $hausnummer) {
            $updated = false;
            $netzgebiet_id = $hausnummer->netzgebiet_id;
            if(!$netzgebiet_id) {
                $this->layout()->setFlash("Netzgebiet nicht gefunden??", "error");
                $this->redirect("AddressDB");
            }

            $gemeinde_id = $hausnummer->strasse->gemeinde_id;
            if(!$gemeinde_id) {
                $this->layout()->setFlash("Strasse '{$hausnummer->strasse->name}' ({$hausnummer->strasse_id}) hat keine Gemeinde...", "error");
                $this->redirect("AddressDB");
            }

            
            /*if(array_key_exists("$gemeinde_search-$netzgebiet_id", $cache["gemeinde"])) {
                $gemeinde = $cache["gemeinde"]["$gemeinde_search-$netzgebiet_id"];
            } else {
                $gemeinde = ADBGemeindeModel::getFirst(['name' => $gemeinde_search, 'netzgebiet_id' => $netzgebiet_id]);
                $cache["gemeinde"]["$gemeinde_search-$netzgebiet_id"] = $gemeinde;
            }*/
            if(array_key_exists($gemeinde_id, $cache["gemeinde"])) {
                $gemeinde = $cache["gemeinde"][$gemeinde_id];
            } else {
                $gemeinde = new ADBGemeinde($gemeinde_id);
            }
            if(!$gemeinde) {
                $this->layout()->setFlash("Gemeinde $gemeinde_id nicht in AdressDB gefunden", "error");
                $this->redirect("AddressDB");
            }

            if($ort_search) {
                if(array_key_exists("$ort_search-$netzgebiet_id", $cache["ort"])) {
                    $ort = $cache["ort"]["$ort_search-$netzgebiet_id"];
                } else {
                    $ort = ADBOrtschaftModel::getFirst(['name' => $ort_search, 'netzgebiet_id' => $netzgebiet_id]);
                    $cache["ort"]["$ort_search-$netzgebiet_id"] = $ort;
                }
                if(!$ort) {
                    $this->layout()->setFlash("Ortschaft '$ort_search' nicht in AdressDB gefunden", "error");
                    $this->redirect("AddressDB");
                }
            }

            if($plz_search) {
                if(array_key_exists("$plz_search-$gemeinde_id", $cache["plz"])) {
                    $plz = $cache["plz"]["$plz_search-$gemeinde_id"];
                } else {
                    $plz = ADBPlzModel::getFirst(['plz' => $plz_search, 'gemeinde_id' => $gemeinde->id]);
                    $cache["plz"]["$plz_search-$gemeinde_id"] = $plz;
                }
                if(!$plz) {
                    $this->layout()->setFlash("PLZ '$plz_search' nicht in AdressDB gefunden", "error");
                    $this->redirect("AddressDB");
                }
            }

            if($strasse_search) {
                if(array_key_exists("$strasse_search-$gemeinde_id", $cache["strasse"])) {
                    $strasse = $cache["strasse"]["$strasse_search-$gemeinde_id"];
                } else {
                    $strasse = ADBStrasseModel::getFirst(['name' => $strasse_search, 'gemeinde_id' => $gemeinde->id]);
                    $cache["strasse"]["$strasse_search-$gemeinde_id"] = $strasse;
                }
                if(!$strasse) {
                    $this->log->debug(__METHOD__ . ": create street '$strasse_search' in gemeinde {$gemeinde->name}");
                    $strasse = ADBStrasseModel::create([
                        'gemeinde_id' => $gemeinde->id,
                        'name' => $strasse_search
                    ]);

                    if(!$strasse->save()) {
                        $this->layout()->setFlash("Fehler beim Speichern der neuen Straße", "error");
                        $this->redirect("AddressDB");
                    }
                    $cache["strasse"]["$strasse_search-$gemeinde_id"] = $strasse;
                }
            }

            //$hausnummer->gemeinde_id = $gemeinde->id;
            if($ort_search && $hausnummer->ortschaft_id != $ort->id) {
                $hausnummer->ortschaft_id = $ort->id;
                $updated = true;
            }
            if($strasse_search && $hausnummer->strasse_id != $strasse->id) {
                $hausnummer->strasse_id = $strasse->id;
                $updated = true;
            }
            if($plz_search && $hausnummer->plz_id != $plz->id) {
                $hausnummer->plz_id = $plz->id;
                $updated = true;
            }

            if($updated) {
                $hausnummer->save(["no_aftersave" => true]);
                $u++;
            }

            if($do_rimo_update) {
                // reload to make sure we have the latest data in caches
                $hausnummer = new ADBHausnummer($hausnummer->id);
                $hausnummer->updateAddressInRimo();
            }


            $i++;
        }

        $this->layout()->setFlash("Bulk Update erfolgreich. $u/$i Adressen updated.", "success");
        $this->redirect("AddressDB");


    }


  protected function apiAction() {
    if(!$this->me->is(["Admin","netowner"]) && !$this->me->can("Preorder")) {
      $this->redirect("Dashboard");
    }
    $do = $this->request->do;
    $data = [];
        
    switch($do) {
      case "findAddress":
        $return = $this->findAddressApi();
        break;
      case "updateAddressStatus":
        $return = $this->updateAddressStatusApi();
        break;
      case "updateUnitStatus":
        $return = $this->updateUnitStatusApi();
        break;
      case "getFilteredBuildings":
        $return = $this->getFilteredBuildingsApi();
        break;
      case "getAddressByHousenumber":
        $return = $this->getAddressByHousenumberApi();
        break;
      case "getUnits":
        $return = $this->getUnitsApi();
        break;
      case "findStreets":
        $return = $this->findStreetsApi();
        break;
      case "findDistricts":
        $return = $this->findDistrictsApi();
        break;
      case "findCities":
        $return = $this->findCitiesApi();
        break;
      case "findZips":
        $return = $this->findZipsApi();
        break;
      case 'findBuildings':
        $return = $this->findBuildingsApi();
        break;
      case 'countWithFilter':
        $return = $this->countWithFilter();
        break;
      case 'getUnit':
        $return = $this->getUnitApi();
        break;
      case 'getFCPsForNetwork':
        $return = $this->getFCPsForNetworkApi();
        break;
      case "findUnit":
        break;
      default:
        $return = false;
    }
    
    if(!is_array($return) || !count($return)) {
      $data = ["status" => "error"];
      $this->returnJson($data);
    }
    $data['status'] = "OK";
    $data['result'] = $return;
    $this->returnJson($data);
  }


  private function countWithFilter() {
      $filter = $this->getPreparedFilter($this->request->filter);
      $filter["netzgebiet_id"] = true;

      return ["count" => ADBHausnummerModel::count($filter)];
  }

    private function updateAddressStatusApi() {
        $address_id = $this->request->id;

        if(!is_numeric($address_id) || $address_id < 1) {
            return ["error" => 1];
            return false;
        }

        $address = new ADBHausnummer($address_id);
        if(!$address->id) {
            return ["error" => 2];
            return false;
        }

        $status_id = $this->request->status_id;
        if(!is_numeric($status_id) || $status_id < 1) {
            return ["error" => 3];
            return false;
        }

        $status = new ADBStatus($status_id);
        if(!$status->id) {
            return ["error" => 4];
            return false;
        }

        $address->status_id = $status_id;
        $address->save();

        $update = [
            "id" => $address_id,
            "status_id" => $status_id,
            "status_code" => $status->code,
            "status_text" => $status->name,
            "units" => []
        ];

        foreach(ADBWohneinheitModel::search(["hausnummer_id" => $address->id]) as $affected_unit) {
            $up = [
                "id" => $affected_unit->id,
                "status_id" => $affected_unit->status_id,
                "status_code" => $affected_unit->status->code,
                "status_text" => $affected_unit->status->name,
            ];

            $update["units"][] = $up;
        }

        return ["message" => "Status saved successfully", "id" => $address_id, "updates" => $update];
    }

    private function updateUnitStatusApi() {
        $unit_id = $this->request->id;

        if(!is_numeric($unit_id) || $unit_id < 1) {
            return ["error" => 1];
            return false;
        }

        $unit = new ADBWohneinheit($unit_id);
        if(!$unit->id) {
            return ["error" => 2];
            return false;
        }

        $status_id = $this->request->status_id;
        if(!is_numeric($status_id) || $status_id < 1) {
            return ["error" => 3];
            return false;
        }

        $status = new ADBStatus($status_id);
        if(!$status->id) {
            return ["error" => 4];
            return false;
        }

        $linkes_units = [];
        foreach(ADBWohneinheitModel::search(["hausnummer_id" => $unit->hausnummer_id]) as $lu) {
            $linkes_units[$lu->id] = $lu->status_id;
        }

        $unit->status_id = $status_id;
        $unit->save();

        $update = [
            "id" => $unit_id,
            "status_id" => $status_id,
            "status_code" => $status->code,
            "status_text" => $status->name,
            "units" => []
        ];

        foreach(ADBWohneinheitModel::search(["hausnummer_id" => $unit->hausnummer_id]) as $affected_unit) {
            if(!array_key_exists($affected_unit->id, $linkes_units)) continue;
            if($linkes_units[$affected_unit->id] == $affected_unit->status_id) continue;

            $up = [
                "id" => $affected_unit->id,
                "status_id" => $affected_unit->status_id,
                "status_code" => $affected_unit->status->code,
                "status_text" => $affected_unit->status->name,
            ];

            $update["units"][] = $up;
        }

        return ["message" => "Status saved successfully", "id" => $unit_id, "updates" => $update];
    }

  private function getUnitApi() {
    $id = $this->request->id;
    if(!$id) return false;
    
    $unit = new ADBWohneinheit($id);
    if(!$unit->id) return false;
    
    $return = $unit->hausnummer->getAddress();
    if((string)$unit) $return .= " ".(string)$unit;
    return["string" => $return];
  }
  
  private function findAddressApi() {
    $addresses = [];
    $search = trim($this->request->q);
    $campagin_id = $this->request->campaign_id;
    $include_gst = $this->request->include_gst ? $this->request->include_gst : false;

    $scluster_ids = [];

    if($campagin_id) {
        $campaign = new Preordercampaign($campagin_id);
        if(!$campaign->id) {
            header("Content-Type: application/json");
            echo json_encode(["results" => []]);
            exit;
        }


        foreach($campaign->salesclusters as $scluster) {
            $scluster_ids[] = $scluster->id;
        }
    } else {
        // get all salesclusters
        foreach(ADBNetzgebietModel::getAll() as $scluster) {
            $scluster_ids[] = $scluster->id;
        }


    }
    $results = [];
    
    $search_parts = explode(" ", $search);

    $ort_search = $strasse_search = $plz_search = $hausnummer_search = $gst_search = [];
    
    foreach($search_parts as $p) {
      $p = $this->db->escape(trim($p));
      if(!$p) continue;
      $ort_search[] = "ortschaft like '$p%'";
      $strasse_search[] = "strasse like '$p%'";
      $plz_search[] = "plz like '%$p%'";
      $hausnummer_search[] = "hausnummer like '%$p%'";
      $gst_search[] = "grund_nr like '%$p%'";
    }
    
    $where = "1=1";
    if(count($scluster_ids)) {
      $where .= " AND netzgebiet_id IN (".implode(', ',$scluster_ids).")";
    }

    if($include_gst) {
      $sql = "SELECT * FROM view_hausnummer WHERE $where AND ((".implode(" OR ", $ort_search).") OR (".implode(" OR ", $strasse_search).") OR (".implode(" OR ", $plz_search).") OR (".implode(" OR ", $hausnummer_search).")  OR (".implode(" OR ", $gst_search).") ) ORDER BY strasse, LENGTH(hausnummer), hausnummer";
    } else {
      $sql = "SELECT * FROM view_hausnummer WHERE $where AND ((".implode(" OR ", $ort_search).") OR (".implode(" OR ", $strasse_search).") OR (".implode(" OR ", $plz_search).") OR (".implode(" OR ", $hausnummer_search).")) ORDER BY strasse, LENGTH(hausnummer), hausnummer";
    }


    $this->log->debug($sql);
    
    $adb = FronkDB::singleton(ADDRESSDB_DBHOST, ADDRESSDB_DBUSER, ADDRESSDB_DBPASS, ADDRESSDB_DBNAME);
    $res = $adb->query($sql);
    $this->log->debug("done");
    
    if(!$adb->num_rows($res)) {
      header("Content-Type: application/json");
      echo json_encode(["results" => []]);
      exit;
    }
    
    while($data = $adb->fetch_object($res)) {
      $address_string = $data->plz." ".$data->ortschaft.", ".$data->strasse." ".$data->hausnummer;
      if($include_gst) {
          $address_string .= " | GST: ".$data->grund_nr;
      }
      $sort_key = $data->plz." ".$data->ortschaft." ".$data->strasse;
      
      $address = [];
      $address['id'] = $data->hausnummer_id;
      $address["text"] = $address_string;
      $address['sort_key'] = $sort_key;
      $addresses[] = $address;
    }
    
    
    // sort results by most occurences of search strings
    $sort = [];
    foreach($addresses as $key => $address) {
      $includes_int = false;
      $count = 0;
      foreach($search_parts as $p) {
        $p = $this->db->escape(trim($p));
        if(!$p) continue;
        if(is_numeric(($p))) {
          $includes_int = true;
          if(substr_count(strtolower($address['text']), strtolower($p))) {
            $count++;
          }
        } else {
          $count += substr_count(strtolower($address['text']), strtolower($p));
        }
      }
      unset($address['sort_key']);
      //echo $address['text']." $p $count<br />\n";
      
      if($includes_int && (($count + 1) - count($search_parts) ) < 1) {
        continue;
      }
      if(!array_key_exists($count, $sort)) {
        $sort[$count] = [];
      }
      $sort[$count][] = $address;
    }
    
    ksort($sort, SORT_NUMERIC);
    $sort = array_reverse($sort, true);
    //var_dump($sort);exit;
    
    foreach($sort as $res) {
      foreach($res as $a) {
        $results[] = $a;
      }
    }
    
    header("Content-Type: application/json");
    echo json_encode(["results" => $results]);
    exit;
    
  }
  
  private function getUnitsApi() {
    $results = [];
    $hausnummer_id = intval($this->request->hausnummer_id);
    
    if(!$hausnummer_id) {
      return ['results' => []];
    }
    
    $units = ADBWohneinheitModel::search(['hausnummer_id' => $hausnummer_id]);
    
    foreach($units as $unit) {
      $u = [];
      $u['id'] = $unit->id;
      $u['extref'] = $unit->extref;
      $u['zip'] = $unit->hausnummer->plz->plzstring;
      $u['city'] = $unit->hausnummer->ortschaft->name;
      $u['street'] = $unit->hausnummer->strasse->name;
      $u['housenumber'] = $unit->hausnummer->hausnummer;
      $u['block'] = $unit->block;
      $u['stiege'] = $unit->stiege;
      $u['stock'] = $unit->stock;
      $u['tuer'] = $unit->tuer;
      $u['extra'] = (string)$unit;
      $u['zusatz'] = $unit->zusatz;
      $u['usage'] = $unit->nutzung;
      $u['oaid'] = $unit->oaid;
      $u['preorder_count'] = count($unit->active_preorders);
      $results[] = $u;
    }

    return ['units' => $results];
  }
  
  private function getAddressByHousenumberApi() {
    $zips = [];
    $hausnummer_id = trim($this->request->hausnummer_id);
    
    if(!is_numeric($hausnummer_id) || $hausnummer_id < 1) {
      return false;
    }
    
    $hausnummer = new ADBHausnummer($hausnummer_id);
    
    $result = [
      'hausnummer_id' => $hausnummer->id,
      'strasse' => $hausnummer->strasse->name,
      'hausnummer' => $hausnummer->hausnummer,
      'plz' => $hausnummer->plz->plz,
      'ort' => $hausnummer->strasse->gemeinde->name,
      'ortschaft' => $hausnummer->ortschaft->name
    ];
    
    return $result;
  }
  
  private function findStreetsApi() {
    $streets = [];
    $search = trim($this->request->q);
    
    foreach(ADBStrasseModel::search(['name%' => $search]) as $street) {
      if(!in_array($street->name, $streets)) {
        $streets[] = $street->name;
      }
    }
    
    $this->returnJson($streets);
  }
  
  private function findZipsApi() {
    $zips = [];
    $search = trim($this->request->q);
    $campaign_id = trim($this->request->campaign_id);
    
    $plz_search = [];
    
    if($campaign_id) {
      $campaign = new Preordercampaign($campaign_id);
      if(!$campaign->id) {
        header("Content-Type: application/json");
        echo json_encode(["results" => []]);
        exit;
      }

      $scluster_ids = [];
      foreach($campaign->salesclusters as $scluster) {
        $scluster_ids[] = $scluster->id;
      }
      $plz_search['netzgebiet_id'] = $scluster_ids;
    }
    
    $plz_search['plzstring%'] = $search;
    
    
    foreach(ADBPlzModel::search($plz_search) as $zip) {
      if(!in_array($zip->plz, $zips)) {
        $zips[] = $zip->plz;
      }
    }
    
    $this->returnJson($zips);
  }
  
  private function findDistrictsApi() {
    $districts = [];
    $search = trim($this->request->q);
    $autocomplete = $this->request->autocomplete;
    $campaign_id = trim($this->request->campaign_id);
    
    $district_search = [];
    
    if($campaign_id) {
      $campaign = new Preordercampaign($campaign_id);
      if(!$campaign->id) {
        header("Content-Type: application/json");
        echo json_encode(["results" => []]);
        exit;
      }

      $scluster_ids = [];
      foreach($campaign->salesclusters as $scluster) {
        $scluster_ids[] = $scluster->id;
      }
      $district_search['netzgebiet_id'] = $scluster_ids;
    }
    
    $district_search['name%'] = "%".$search;
    
    foreach(ADBOrtschaftModel::search($district_search) as $district) {
      if(!in_array($district->name, $districts)) {
        $districts[] = $district->name;
      }
    }
    /*
    if(is_numeric($search)) {
      $adb = FronkDB::singleton(ADDRESSDB_DBHOST, ADDRESSDB_DBUSER, ADDRESSDB_DBPASS, ADDRESSDB_DBNAME);
      $sql = "SELECT ortschaft_id from view_wohneinheit WHERE ortschaft like '%$search%' GROUP BY ortschaft_id";
      $res = $adb->query($sql);
      
      if($adb->num_rows($res)) {
        while($data = $adb->fetch_object($res)) {
          $ort_ids[] = $data->ortschaft_id;
        }
      }
    }
    
    if($ort_ids) {
      foreach($ort_ids as $oid) {
        $results[] = new ADBOrtschaft($oid);
      }
    } else {
      $results = ADBOrtschaftModel::search(['name%' => $search]);
    }
    
    if($autocomplete) {
      foreach($results as $city) {
        if(!in_array($city->name, $cities)) {
          $cities[] = $city->name;
        }
      }
      $this->returnJson($cities);
    }
    
    foreach($results as $city) {
      $gemeinde = new ADBGemeinde($city->gemeinde_id);

      $data = [];
      $data['id'] = $city->id;
      $data['gemeinde_id'] = $city->gemeinde_id;
      $data['gemeinde'] = $gemeinde->name;
      $data['kennziffer'] = $city->kennziffer;
      $data['name'] = $city->name;
      $cities[] = $data;
    }
    */
    $this->returnJson($districts);
    //return ['cities' => $cities];
  }
  
  private function findCitiesApi() {
    $cities = [];
    $search = $this->request->q;
    //$autocomplete = $this->request->autocomplete;
    $campaign_id = trim($this->request->campaign_id);
    
    $city_search = [];
    
    if($campaign_id) {
      $campaign = new Preordercampaign($campaign_id);
      if(!$campaign->id) {
        header("Content-Type: application/json");
        echo json_encode(["results" => []]);
        exit;
      }

      $scluster_ids = [];
      foreach($campaign->salesclusters as $scluster) {
        $scluster_ids[] = $scluster->id;
      }
      $city_search['netzgebiet_id'] = $scluster_ids;
    }
    
    $city_search['name%'] = "%".$search;
    
    foreach(ADBGemeindeModel::search($city_search) as $city) {
      if(!in_array($city->name, $cities)) {
        $cities[] = $city->name;
      }
    }
    $this->returnJson($cities);
    
  }
  
  private function getFilteredBuildingsApi() {
    $buildings = [];
    $filter = $this->request->filter;
    
    
    $results = BuildingModel::search($filter);
    
    foreach($results as $building) {
      $data = $building->data;
      $data->id = $building->id;
      $buildings[] = $data;
    }
    
    return ["buildings" => $buildings];
  }
  
  private function findBuildingsApi() {
    $buildings = [];
    $search = $this->request->search;
    $city_id = intval($this->request->city_id);
    
    $sql = "SELECT * FROM view_hausnummer WHERE (ortschaft like '%$search%' OR strasse like '%$search%' OR plz like '%$search%' OR  hausnummer like '%$search%')";
    if($city_id) {
      $sql .= " AND ortschaft_id=$city_id";
    }
    
    $adb = FronkDB::singleton(ADDRESSDB_DBHOST, ADDRESSDB_DBUSER, ADDRESSDB_DBPASS, ADDRESSDB_DBNAME);
    $res = $adb->query($sql);
    if(!$adb->num_rows($res)) {
      return ["count" => 0, "buildings" => []];
    }
    while($data = $adb->fetch_object($res)) {
      $buildings[$data->hausnummer_id] = $data;
    }
    
    $unsorted = [];
    
    foreach($buildings as $building) {
      $u = [];
      $u['id'] = $building->hausnummer_id;
      $u['street'] = $building->strasse . " ".$building->hausnummer;
      $u['zip'] = $building->plz;
      $u['city'] = $building->ortschaft;
      $u['oaid'] = ($building->oaid) ? $building->oan_oaid : "";
      $u['code'] = ($building->code) ? $building->code : "";
      $u['units'] = ($building->units) ? $building->units : 1;
      //$u['units_used'] = $building->getUsedTerminationCount(true);
      $u['units_used'] = 1;
      //$u['status'] = $building->status->name;
      $u['status'] = "";
      $unsorted[$building->strasse."-".$building->hausnummer_id] = $u;
    }
    
    ksort($unsorted);
    
    $results = [];
    foreach($unsorted as $r) {
      $results[] = $r;
      /*if(count($results) >= 20) {
        break;
      }*/
    }
    
    return ["count" => count($buildings), "buildings" => $results];
    
  }

    protected function getFCPsForNetworkApi(): array {
        if (!$this->request->network_id) return [];

        return array_map(
            fn($fcp) => ["id" => $fcp->name ?? null, "text" => $fcp->name ?? null, 'lat' => $fcp->gps_lat ?? null, 'lng' => $fcp->gps_long ?? null],
            ADBRimoFcp::getAll(["netzgebiet_id" => intval($this->request->network_id)]) ?? []
        );
    }

}