<?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);
    $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;
        $my_adb_networks[$network->adb_netzgebiet_id] = new ADBNetzgebiet($network->adb_netzgebiet_id);
      }
    }
    //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);
      $addresses = ADBHausnummerModel::search($addressdb_filter, $pagination);
    } else if(count($my_adb_networks)) {
      $pagination['maxItems'] = ADBHausnummerModel::count($addressdb_filter);
      $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));
    }
    
    
  }
  
  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("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['visbility'];
    } else {
      $new_filter["visibility"] = ["public", "private"];
      unset($filter['visibility']);
    }
    
    if(is_array($filter) && count($filter)) {
        foreach($filter as $name => $value) {
          if(strlen($value) > 0) $new_filter[$name] = $value;
      }
    }
    
    return $new_filter;
  }
  
  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;
        $my_adb_networks[$network->adb_netzgebiet_id] = new ADBNetzgebiet($network->adb_netzgebiet_id);
      }
    }
    $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'] 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 exportAction() {
    $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;
        $my_adb_networks[$network->adb_netzgebiet_id] = new ADBNetzgebiet($network->adb_netzgebiet_id);
      }
    }
    
    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);
    
    $this->layout()->setTemplate("AddressDB/export.csv");
    $this->layout()->set("res", $res);
    
    //var_dump($filter, $hausnummern);exit;
    
    
    
  }
  
  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 "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 'getUnit':
        $return = $this->getUnitApi();
        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 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);
    
    $campaign = new Preordercampaign($campagin_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;
    }
    
    $results = [];
    
    $search_parts = explode(" ", $search);

    $ort_search = $strasse_search = $plz_search = $hausnummer_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%'";
    }
    
    $where = "1=1";
    if(count($scluster_ids)) {
      $where .= " AND netzgebiet_id IN (".implode(', ',$scluster_ids).")";
    }
    
    $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;
      $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;
      $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];
    
  }
}