navit/navit/search.c

/**
 * ZANavi, Zoff Android Navigation system.
 * Copyright (C) 2011-2012 Zoff <zoff@zoff.cc>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2008 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include <stdlib.h>
#include <glib.h>
#include <string.h>
#include <math.h>
#include "debug.h"
#include "projection.h"
#include "item.h"
#include "map.h"
#include "mapset.h"
#include "coord.h"
#include "transform.h"
#include "search.h"
#include "country.h"
#include "navit.h"

#if HAVE_API_ANDROID
#include "android.h"
#endif
#include "layout.h"
#include "map.h"
#include "linguistics.h"

struct search_list_level
{
        struct mapset *ms;
        struct search_list_common *parent;
        struct attr *attr;
        int partial;
        int selected;
        struct mapset_search *search;
        GHashTable *hash;
        GList *list, *curr, *last;
};

struct interpolation
{
        int side, mode, rev;
        char *first, *last, *curr;
};

struct search_list
{
        struct mapset *ms;
        struct item *item;
        int level;
        struct search_list_level levels[4];
        struct search_list_result result;
        struct search_list_result last_result;
        int last_result_valid;
        char *postal;
        struct interpolation inter;
};

static guint search_item_hash_hash(gconstpointer key)
{
        const struct item *itm = key;
        gconstpointer hashkey = (gconstpointer) GINT_TO_POINTER(itm->id_hi ^ itm->id_lo);
        return g_direct_hash(hashkey);
}

static gboolean search_item_hash_equal(gconstpointer a, gconstpointer b)
{
        const struct item *itm_a = a;
        const struct item *itm_b = b;
        if (item_is_equal_id(*itm_a, *itm_b))
                return TRUE;
        return FALSE;
}

struct search_list *
search_list_new(struct mapset *ms)
{
        struct search_list *ret;

        ret=g_new0(struct search_list, 1);
        ret->ms = ms;

        return ret;
}

static void search_list_search_free(struct search_list *sl, int level);

static int search_list_level(enum attr_type attr_type)
{
        switch (attr_type)
        {
                case attr_country_all:
                case attr_country_id:
                case attr_country_iso2:
                case attr_country_iso3:
                case attr_country_car:
                case attr_country_name:
                        return 0;
                case attr_town_postal:
                        return 1;
                case attr_town_name:
                case attr_district_name:
                case attr_town_or_district_name:
                        return 1;
                case attr_street_name:
                        return 2;
                case attr_house_number:
                        return 3;
                case attr_postal:
                        return -1;
                default:
                        dbg(0, "unknown search '%s'\n", attr_to_name(attr_type));
                        return -1;
        }
}

static void interpolation_clear(struct interpolation *inter)
{
        inter->mode = inter->side = 0;
        g_free(inter->first);
        g_free(inter->last);
        g_free(inter->curr);
        inter->first = inter->last = inter->curr = NULL;
}

void search_list_search(struct search_list *this_, struct attr *search_attr, int partial)
{
        struct search_list_level *le;
        int level = search_list_level(search_attr->type);
        this_->item = NULL;
        interpolation_clear(&this_->inter);
        //dbg(0,"## enter\n");
        //dbg(0,"## level=%d\n", level);
        if (level != -1)
        {
                this_->result.id = 0;
                this_->level = level;
                le = &this_->levels[level];
                search_list_search_free(this_, level);
                le->attr = attr_dup(search_attr);
                le->partial = partial;
                if (level > 0)
                {
                        le = &this_->levels[level - 1];
                        le->curr = le->list;
                }
                //dbg(0,"## le=%p partial=%d\n", le, partial);
        }
        else if (search_attr->type == attr_postal)
        {
                g_free(this_->postal);
                this_->postal = g_strdup(search_attr->u.str);
        }
        //dbg(0,"## return\n");
}

struct search_list_common *
search_list_select(struct search_list *this_, enum attr_type attr_type, int id, int mode)
{
        int level = search_list_level(attr_type);
        int num = 0;
        struct search_list_level *le;
        struct search_list_common *slc;
        GList *curr;
        le = &this_->levels[level];
        curr = le->list;
        if (mode > 0 || !id)
                le->selected = mode;
        //dbg(0,"enter level=%d %d %d %p\n", level, id, mode, curr);
        while (curr)
        {
                num++;
                if (!id || num == id)
                {
                        slc = curr->data;
                        slc->selected = mode;
                        if (id)
                        {
                                le->last = curr;
                                //dbg(0,"found\n");
                                return slc;
                        }
                }
                curr = g_list_next(curr);
        }
        //dbg(0,"not found\n");
        return NULL;
}

static void search_list_common_new(struct item *item, struct search_list_common *common)
{
        struct attr attr;
        if (item_attr_get(item, attr_town_name, &attr))
                common->town_name = map_convert_string(item->map, attr.u.str);
        else
                common->town_name = NULL;
        if (item_attr_get(item, attr_county_name, &attr))
                common->county_name = map_convert_string(item->map, attr.u.str);
        else
                common->county_name = NULL;
        if (item_attr_get(item, attr_district_name, &attr))
                common->district_name = map_convert_string(item->map, attr.u.str);
        else
                common->district_name = NULL;
        if (item_attr_get(item, attr_postal, &attr))
                common->postal = map_convert_string(item->map, attr.u.str);
        else if (item_attr_get(item, attr_town_postal, &attr))
                common->postal = map_convert_string(item->map, attr.u.str);
        else
                common->postal = NULL;
        if (item_attr_get(item, attr_postal_mask, &attr))
                common->postal_mask = map_convert_string(item->map, attr.u.str);
        else
                common->postal_mask = NULL;
}

static void search_list_common_destroy(struct search_list_common *common)
{
        map_convert_free(common->town_name);
        map_convert_free(common->district_name);
        map_convert_free(common->county_name);
        map_convert_free(common->postal);
        map_convert_free(common->postal_mask);
}

static struct search_list_country *
search_list_country_new(struct item *item)
{
        struct search_list_country *ret=g_new0(struct search_list_country, 1);
        struct attr attr;

        ret->common.item = ret->common.unique = *item;
        if (item_attr_get(item, attr_country_car, &attr))
                ret->car = g_strdup(attr.u.str);
        if (item_attr_get(item, attr_country_iso2, &attr))
        {
#if HAVE_API_ANDROID
                ret->iso2=g_malloc(strlen(attr.u.str)+1);
                strtolower(ret->iso2, attr.u.str);
#else 
                ret->iso2 = g_strdup(attr.u.str);
#endif          
                ret->flag = g_strdup_printf("country_%s", ret->iso2);
        }
        if (item_attr_get(item, attr_country_iso3, &attr))
                ret->iso3 = g_strdup(attr.u.str);
        if (item_attr_get(item, attr_country_name, &attr))
                ret->name = g_strdup(attr.u.str);
        return ret;
}

static void search_list_country_destroy(struct search_list_country *this_)
{
        g_free(this_->car);
        g_free(this_->iso2);
        g_free(this_->iso3);
        g_free(this_->flag);
        g_free(this_->name);
        g_free(this_);
}

static struct search_list_town *
search_list_town_new(struct item *item)
{
        struct search_list_town *ret=g_new0(struct search_list_town, 1);
        struct attr attr;
        struct coord c;

        ret->itemt = *item;
        ret->common.item = ret->common.unique = *item;

        if (item_attr_get(item, attr_town_streets_item, &attr))
        {
                //dbg(1, "town_assoc 0x%x 0x%x\n", attr.u.item->id_hi, attr.u.item->id_lo);
                ret->common.unique = *attr.u.item;
        }

        search_list_common_new(item, &ret->common);

        if (item_attr_get(item, attr_county_name, &attr))
        {
                ret->county = map_convert_string(item->map, attr.u.str);
        }
        else
        {
                ret->county = NULL;
        }

        if (item_coord_get(item, &c, 1))
        {
                ret->common.c=g_new(struct pcoord, 1);
                ret->common.c->x = c.x;
                ret->common.c->y = c.y;
                ret->common.c->pro = map_projection(item->map);
        }
        else
        {
                // some error with lat/lng !!
                // but still return something, or app will crash
                ret->common.c=g_new(struct pcoord, 1);
                ret->common.c->x = 0;
                ret->common.c->y = 0;
                ret->common.c->pro = map_projection(item->map);
        }
        return ret;
}

static void search_list_town_destroy(struct search_list_town *this_)
{
        map_convert_free(this_->county);
        search_list_common_destroy(&this_->common);
        if (this_->common.c)
                g_free(this_->common.c);
        g_free(this_);
}

static struct search_list_street *
search_list_street_new(struct item *item)
{
        struct search_list_street *ret=g_new0(struct search_list_street, 1);
        struct attr attr;
        struct coord c;

        ret->common.item = ret->common.unique = *item;
        if (item_attr_get(item, attr_street_name, &attr))
        {
                ret->name = map_convert_string(item->map, attr.u.str);
        }
        else
        {
                ret->name = NULL;
        }
        search_list_common_new(item, &ret->common);
        if (item_coord_get(item, &c, 1))
        {
                ret->common.c=g_new(struct pcoord, 1);
                ret->common.c->x = c.x;
                ret->common.c->y = c.y;
                ret->common.c->pro = map_projection(item->map);
        }
        else
        {
                // some error with lat/lng !!
                // but still return something, or app will crash
                ret->common.c=g_new(struct pcoord, 1);
                ret->common.c->x = 0;
                ret->common.c->y = 0;
                ret->common.c->pro = map_projection(item->map);
        }
        return ret;
}

static void search_list_street_destroy(struct search_list_street *this_)
{
        map_convert_free(this_->name);
        search_list_common_destroy(&this_->common);
        if (this_->common.c)
        {
                g_free(this_->common.c);
        }
        g_free(this_);
}

static char *
search_interpolate(struct interpolation *inter)
{
        dbg(1, "interpolate %s-%s %s\n", inter->first, inter->last, inter->curr);
        if (!inter->first || !inter->last)
                return NULL;
        if (!inter->curr)
                inter->curr = g_strdup(inter->first);
        else
        {
                if (strcmp(inter->curr, inter->last))
                {
                        int next = atoi(inter->curr) + (inter->mode ? 2 : 1);
                        g_free(inter->curr);
                        if (next == atoi(inter->last))
                                inter->curr = g_strdup(inter->last);
                        else
                                inter->curr = g_strdup_printf("%d", next);
                }
                else
                {
                        g_free(inter->curr);
                        inter->curr = NULL;
                }
        }
        dbg(1, "interpolate result %s\n", inter->curr);
        return inter->curr;
}

static void search_interpolation_split(char *str, struct interpolation *inter)
{
        char *pos = strchr(str, '-');
        char *first, *last;
        int len;
        if (!pos)
        {
                inter->first = g_strdup(str);
                inter->last = g_strdup(str);
                inter->rev = 0;
                return;
        }
        len = pos - str;
        first = g_malloc(len + 1);
        strncpy(first, str, len);
        first[len] = '\0';
        last = g_strdup(pos + 1);
        dbg(1, "%s = %s - %s\n", str, first, last);
        if (atoi(first) > atoi(last))
        {
                inter->first = last;
                inter->last = first;
                inter->rev = 1;
        }
        else
        {
                inter->first = first;
                inter->last = last;
                inter->rev = 0;
        }
}

static int search_setup_interpolation(struct item *item, enum attr_type i0, enum attr_type i1, enum attr_type i2, struct interpolation *inter)
{
        struct attr attr;
        g_free(inter->first);
        g_free(inter->last);
        g_free(inter->curr);
        inter->first = inter->last = inter->curr = NULL;
        dbg(1, "setup %s\n", attr_to_name(i0));
        if (item_attr_get(item, i0, &attr))
        {
                search_interpolation_split(attr.u.str, inter);
                inter->mode = 0;
        }
        else if (item_attr_get(item, i1, &attr))
        {
                search_interpolation_split(attr.u.str, inter);
                inter->mode = 1;
        }
        else if (item_attr_get(item, i2, &attr))
        {
                search_interpolation_split(attr.u.str, inter);
                inter->mode = 2;
        }
        else
                return 0;
        return 1;
}

static int search_match(char *str, char *search, int partial)
{
        if (!partial)
                return (!g_strcasecmp(str, search));
        else
                return (!g_strncasecmp(str, search, strlen(search)));
}

static struct pcoord *
search_house_number_coordinate(struct item *item, struct interpolation *inter)
{
        struct pcoord *ret=g_new(struct pcoord, 1);
        ret->pro = map_projection(item->map);
        if (item_is_point(*item))
        {
                struct coord c;
                if (item_coord_get(item, &c, 1))
                {
                        ret->x = c.x;
                        ret->y = c.y;
                }
                else
                {
                        g_free(ret);
                        ret = NULL;
                }
        }
        else
        {
                int count, max = 1024;
                int hn_pos, hn_length;
                struct coord *c = g_alloca(sizeof(struct coord) * max);
                item_coord_rewind(item);
                count = item_coord_get(item, c, max);
                hn_length = atoi(inter->last) - atoi(inter->first);
                if (inter->rev)
                        hn_pos = atoi(inter->last) - atoi(inter->curr);
                else
                        hn_pos = atoi(inter->curr) - atoi(inter->first);
                if (count)
                {
                        int i, distance_sum = 0, hn_distance;
                        int *distances = g_alloca(sizeof(int) * (count - 1));
                        dbg(1, "count=%d hn_length=%d hn_pos=%d (%s of %s-%s)\n", count, hn_length, hn_pos, inter->curr, inter->first, inter->last);
                        if (!hn_length)
                        {
                                hn_length = 2;
                                hn_pos = 1;
                        }
                        if (count == max)
                                dbg(0, "coordinate overflow\n");
                        for (i = 0; i < count - 1; i++)
                        {
                                distances[i] = navit_sqrt(transform_distance_sq(&c[i], &c[i + 1]));
                                distance_sum += distances[i];
                                dbg(1, "distance[%d]=%d\n", i, distances[i]);
                        }
                        dbg(1, "sum=%d\n", distance_sum);
                        hn_distance = distance_sum * hn_pos / hn_length;
                        dbg(1, "hn_distance=%d\n", hn_distance);
                        i = 0;
                        while (i < count - 1 && hn_distance > distances[i])
                                hn_distance -= distances[i++];
                        dbg(1, "remaining distance=%d from %d\n", hn_distance, distances[i]);
                        ret->x = (c[i + 1].x - c[i].x) * hn_distance / distances[i] + c[i].x;
                        ret->y = (c[i + 1].y - c[i].y) * hn_distance / distances[i] + c[i].y;
                }
        }
        return ret;
}

static struct search_list_house_number *
search_list_house_number_new(struct item *item, struct interpolation *inter, char *inter_match, int inter_partial)
{
        struct search_list_house_number *ret=g_new0(struct search_list_house_number, 1);
        struct attr attr;
        char *hn;

        // dbg(0,"@@@@ enter @@@@\n");

        ret->common.item = ret->common.unique = *item;
        //if (item_attr_get(item, attr_street_name, &attr))
        //      dbg(0,"xx1 %s\n",attr.u.str);
        if (item_attr_get(item, attr_house_number, &attr))
                ret->house_number = map_convert_string(item->map, attr.u.str);
        else
        {
                //if (item_attr_get(item, attr_street_name, &attr))
                //      dbg(0,"xx2 %s\n",attr.u.str);
                for (;;)
                {
                        //dbg(0,"interpolate 11");
                        ret->interpolation = 1;
                        switch (inter->side)
                        {
                                case 0:
                                        //dbg(0,"interpolate 11 0");
                                        inter->side = -1;
                                        search_setup_interpolation(item, attr_house_number_left, attr_house_number_left_odd, attr_house_number_left_even, inter);
                                case -1:
                                        //dbg(0,"interpolate 11 -1");
                                        if ((hn = search_interpolate(inter)))
                                                break;
                                        inter->side = 1;
                                        search_setup_interpolation(item, attr_house_number_right, attr_house_number_right_odd, attr_house_number_right_even, inter);
                                case 1:
                                        //dbg(0,"interpolate 11 1");
                                        if ((hn = search_interpolate(inter)))
                                                break;
                                default:
                                        //dbg(0,"interpolate 11 default");
                                        g_free(ret);
                                        return NULL;
                        }
                        if (search_match(hn, inter_match, inter_partial))
                        {
                                //dbg(0,"interpolate 22");
                                //dbg(0,"match %s %s-%s\n",hn, inter->first, inter->last);
                                ret->house_number = map_convert_string(item->map, hn);
                                break;
                        }
                }
        }
        //dbg(0,"interpolate 33");
        search_list_common_new(item, &ret->common);
        ret->common.c = search_house_number_coordinate(item, ret->interpolation ? inter : NULL);
        //dbg(0,"interpolate 44");
        return ret;
}

static void search_list_house_number_destroy(struct search_list_house_number *this_)
{
        map_convert_free(this_->house_number);
        search_list_common_destroy(&this_->common);
        if (this_->common.c)
                g_free(this_->common.c);
        g_free(this_);
}

static void search_list_result_destroy(int level, void *p)
{
        switch (level)
        {
                case 0:
                        search_list_country_destroy(p);
                        break;
                case 1:
                        search_list_town_destroy(p);
                        break;
                case 2:
                        search_list_street_destroy(p);
                        break;
                case 3:
                        search_list_house_number_destroy(p);
                        break;
        }
}

static void search_list_search_free(struct search_list *sl, int level)
{
        //dbg(0,"enter\n");

        struct search_list_level *le = &sl->levels[level];
        GList *next, *curr;
        if (le->search)
        {
                mapset_search_destroy(le->search);
                le->search = NULL;
        }
#if 0 /* FIXME */
        if (le->hash)
        {
                g_hash_table_destroy(le->hash);
                le->hash=NULL;
        }
#endif
        curr = le->list;
        while (curr)
        {
                search_list_result_destroy(level, curr->data);
                next = g_list_next(curr);
                curr = next;
        }
        attr_free(le->attr);
        g_list_free(le->list);
        le->list = NULL;
        le->curr = NULL;
        le->last = NULL;

        //dbg(0,"return\n");
}

char *
search_postal_merge(char *mask, char *new)
{
        int i;
        char *ret = NULL;
        dbg(1, "enter %s %s\n", mask, new);
        if (!new)
                return NULL;
        if (!mask)
                return g_strdup(new);
        i = 0;
        while (mask[i] && new[i])
        {
                if (mask[i] != '.' && mask[i] != new[i])
                        break;
                i++;

        }
        if (mask[i])
        {
                ret = g_strdup(mask);
                while (mask[i])
                        ret[i++] = '.';
        }
        dbg(1, "merged %s with %s as %s\n", mask, new, ret);
        return ret;
}

char *
search_postal_merge_replace(char *mask, char *new)
{
        char *ret = search_postal_merge(mask, new);
        if (!ret)
                return mask;
        g_free(mask);
        return ret;
}

static int postal_match(char *postal, char *mask)
{
        for (;;)
        {
                if ((*postal != *mask) && (*mask != '.'))
                        return 0;
                if (!*postal)
                {
                        if (!*mask)
                                return 1;
                        else
                                return 0;
                }
                postal++;
                mask++;
        }
}

static int search_add_result(struct search_list_level *le, struct search_list_common *slc)
{
        struct search_list_common *slo;
        char *merged;

        //dbg(0,"enter\n");

        //slo=g_hash_table_lookup(le->hash, &slc->unique);
        //if (!slo) {
        //g_hash_table_insert(le->hash, &slc->unique, slc);
        if (slc->postal && !slc->postal_mask)
        {
                slc->postal_mask = g_strdup(slc->postal);
        }
        // ******
        g_list_free(le->list);
        le->list = NULL;
        // ******
        le->list = g_list_append(le->list, slc);
        return 1;
        //}
        merged = search_postal_merge(slo->postal_mask, slc->postal);
        if (merged)
        {
                g_free(slo->postal_mask);
                slo->postal_mask = merged;
        }
        return 0;
}

struct search_list_result *
search_list_get_result(struct search_list *this_)
{
        struct search_list_level *le, *leu;
        int level = this_->level;
        struct attr attr2;
        int has_street_name = 0;

        //dbg(0,"******* enter *******\n");
        le = &this_->levels[level];
        //dbg(0,"le=%p\n", le);
        for (;;)
        {
                //dbg(0,"le->search=%p\n", le->search);
                if (!le->search)
                {
                        //dbg(0,"partial=%d level=%d\n", le->partial, level);
                        if (!level)
                                le->parent = NULL;
                        else
                        {
                                leu = &this_->levels[level - 1];
                                //dbg(0,"leu->curr=%p\n", leu->curr);
                                for (;;)
                                {
                                        //dbg(0,"*********########");

                                        struct search_list_common *slc;
                                        if (!leu->curr)
                                        {
                                                return NULL;
                                        }
                                        le->parent = leu->curr->data;
                                        leu->last = leu->curr;
                                        leu->curr = g_list_next(leu->curr);
                                        slc = (struct search_list_common *) (le->parent);
                                        if (!slc)
                                                break;
                                        if (slc->selected == leu->selected)
                                                break;
                                }
                        }
#if 0
                        if (le->parent)
                        {
                                dbg(0,"mapset_search_new with item(%d,%d)\n", le->parent->item.id_hi, le->parent->item.id_lo);
                        }
                        else
                        {
                                dbg(0,"NO parent!!\n");
                        }
                        dbg(0,"############## attr=%s\n", attr_to_name(le->attr->type));
#endif
                        le->search = mapset_search_new(this_->ms, &le->parent->item, le->attr, le->partial);
                        // ** DOC ** mapset_search_new(struct mapset *ms, struct item *item, struct attr *search_attr, int partial)
                        le->hash = g_hash_table_new(search_item_hash_hash, search_item_hash_equal);
                }

                //dbg(0,"le->search=%p\n", le->search);

                if (!this_->item)
                {
                        //dbg(0,"sssss 1");
                        this_->item = mapset_search_get_item(le->search);
                        //dbg(0,"sssss 1 %p\n",this_->item);
                }

                if (this_->item)
                {
                        void *p = NULL;
                        //dbg(0,"id_hi=%d id_lo=%d\n", this_->item->id_hi, this_->item->id_lo);
                        if (this_->postal)
                        {
                                struct attr postal;
                                if (item_attr_get(this_->item, attr_postal_mask, &postal))
                                {
                                        if (!postal_match(this_->postal, postal.u.str))
                                                continue;
                                }
                                else if (item_attr_get(this_->item, attr_postal, &postal))
                                {
                                        if (strcmp(this_->postal, postal.u.str))
                                                continue;
                                }
                        }
                        this_->result.country = NULL;
                        this_->result.town = NULL;
                        this_->result.street = NULL;
                        this_->result.c = NULL;
                        //dbg(0,"case x LEVEL start %d\n",level);
                        switch (level)
                        {
                                case 0:
                                        //dbg(0,"case 0 COUNTRY");
                                        p = search_list_country_new(this_->item);
                                        this_->result.country = p;
                                        this_->result.country->common.parent = NULL;
                                        this_->item = NULL;
                                        break;
                                case 1:
                                        //dbg(0,"case 1 TOWN");
                                        p = search_list_town_new(this_->item);
                                        this_->result.town = p;
                                        this_->result.town->common.parent = this_->levels[0].last->data;
                                        this_->result.country = this_->result.town->common.parent;
                                        this_->result.c = this_->result.town->common.c;
                                        this_->item = NULL;
                                        break;
                                case 2:
                                        //dbg(0,"case 2 STREET");
                                        p = search_list_street_new(this_->item);
                                        this_->result.street = p;
                                        this_->result.street->common.parent = this_->levels[1].last->data;
                                        this_->result.town = this_->result.street->common.parent;
                                        this_->result.country = this_->result.town->common.parent;
                                        this_->result.c = this_->result.street->common.c;
                                        this_->item = NULL;
                                        break;
                                case 3:
                                        //dbg(0,"case 3 HOUSENUMBER");
                                        has_street_name = 0;

                                        // if this housenumber has a streetname tag, set the name now
                                        if (item_attr_get(this_->item, attr_street_name, &attr2))
                                        {
                                                // dbg(0,"streetname: %s\n",attr2.u.str);
                                                has_street_name = 1;
                                        }

                                        //dbg(0,"case 3 XXXX 1\n");
                                        p = search_list_house_number_new(this_->item, &this_->inter, le->attr->u.str, le->partial);
                                        //dbg(0,"case 3 XXXX 2\n");
                                        if (!p)
                                        {
                                                interpolation_clear(&this_->inter);
                                                this_->item = NULL;
                                                continue;
                                        }
                                        //dbg(0,"case 3 XXXX 3\n");
                                        this_->result.house_number = p;
                                        if (!this_->result.house_number->interpolation)
                                        {
                                                this_->item = NULL;
                                        }

                                        this_->result.house_number->common.parent = this_->levels[2].last->data;
                                        this_->result.street = this_->result.house_number->common.parent;
                                        this_->result.town = this_->result.street->common.parent;
                                        this_->result.country = this_->result.town->common.parent;
                                        this_->result.c = this_->result.house_number->common.c;

                                        //dbg(0,"case 3 XXXX 4\n");
                                        if (has_street_name == 1)
                                        {
                                                gchar *tmp_name = g_strdup(attr2.u.str);
                                                this_->result.street->name = tmp_name;
                                                //dbg(0,"res streetname=%s\n",this_->result.street->name);
                                        }
                                        else
                                        {
                                                //
                                                // this crashes all the time -> so dont use!
                                                //static struct search_list_street null_street;
                                                //this_->result.street=&null_street;
                                                // this crashes all the time -> so dont use!
                                                //
                                                this_->result.street->name = NULL;
                                        }
                                        //dbg(0,"case 3 XXXX 5\n");
                                        break;
                        }
                        // CASE END *********


                        if (p)
                        {
                                if (search_add_result(le, p))
                                {
                                        //** this_->result.id++;
                                        this_->result.id = 0;
                                        //dbg(0,"++++ return result\n");
                                        return &this_->result;
                                }
                                else
                                {
                                        search_list_result_destroy(level, p);
                                        // return &this_->result;
                                }
                        }
                }
                else
                {
                        mapset_search_destroy(le->search);
                        le->search = NULL;
                        g_hash_table_destroy(le->hash);
                        if (!level)
                        {
                                break;
                        }
                }
        }
        return NULL;
}

void search_list_destroy(struct search_list *this_)
{
        g_free(this_->postal);
        g_free(this_);
}

void search_init(void)
{
}

static char *
search_fix_spaces(char *str)
{
        int i;
        int len = strlen(str);
        char c, *s, *d, *ret = g_strdup(str);

        for (i = 0; i < len; i++)
        {
                if (ret[i] == ',' || ret[i] == ',' || ret[i] == '/')
                        ret[i] = ' ';
        }
        s = ret;
        d = ret;
        len = 0;
        do
        {
                c = *s++;
                if (c != ' ' || len != 0)
                {
                        *d++ = c;
                        len++;
                }
                while (c == ' ' && *s == ' ')
                        s++;
                if (c == ' ' && *s == '\0')
                {
                        d--;
                        len--;
                }
        }
        while (c);
        return ret;
}

static GList *
search_split_phrases(char *str)
{
        char *tmp, *s, *d;
        GList *ret = NULL;
        s = str;
        do
        {
                tmp = g_strdup(s);
                d = tmp + strlen(s) - 1;
                ret = g_list_append(ret, g_strdup(s));
                while (d >= tmp)
                {
                        if (*d == ' ')
                        {
                                *d = '\0';
                                ret = g_list_append(ret, g_strdup(tmp));
                        }
                        d--;
                }
                g_free(tmp);
                do
                {
                        s++;
                        if (*s == ' ')
                        {
                                s++;
                                break;
                        }
                }
                while (*s != '\0');
        }
        while (*s != '\0');
        return ret;
}

static GList *
search_address_housenumber_real(GList *result_list, struct search_list *sl, char *street_name, GList *phrases, GList *exclude1, GList *exclude2, GList *exclude3, int partial, struct jni_object *jni)
{
        struct search_list_result *slr;
        struct coord_geo g;
        struct coord c;

        //dbg(0,"enter\n");

        while ((slr = search_list_get_result(sl)))
        {
                if (offline_search_break_searching == 1)
                {
                        break;
                }

                // does the streetname of the housenumber match the street we want?
                if (slr != NULL)
                {
                        if (slr->street != NULL)
                                if ((street_name != NULL) && (slr->street->name != NULL))
                                {

                                        if (strcmp(slr->street->name, street_name) == 0)
                                        {
                                                char *buffer;
                                                // coords of result
                                                c.x = slr->house_number->common.c->x;
                                                c.y = slr->house_number->common.c->y;
                                                transform_to_geo(slr->house_number->common.c->pro, &c, &g);
                                                // SHN -> street with house number
                                                // return a string like: "SHN:H111L5555:16.766:48.76:full address name is at the end"
                                                // ca. 9 chars : ca. 9 chars : max. 100 max. 100 max. 100 max. 15 chars -> this sould be max. about 335 chars long
                                                if (slr->town->common.postal == NULL)
                                                {
                                                        buffer = g_strdup_printf("SHN:H%dL%d:%f:%f:%.101s,%.101s, %.101s %.15s", slr->street->common.item.id_hi, slr->street->common.item.id_lo, g.lat, g.lng, slr->country->name, slr->town->common.town_name, slr->street->name, slr->house_number->house_number);
                                                }
                                                else
                                                {
                                                        buffer = g_strdup_printf("SHN:H%dL%d:%f:%f:%.101s,%.7s %.101s, %.101s %.15s", slr->street->common.item.id_hi, slr->street->common.item.id_lo, g.lat, g.lng, slr->country->name, slr->town->common.postal, slr->town->common.town_name, slr->street->name,
                                                                        slr->house_number->house_number);
                                                }

                                                //dbg(0,"res=%s\n",buffer);

                                                // deactivated now * result_list=g_list_prepend(result_list,g_strdup(buffer));
#ifdef HAVE_API_ANDROID
                                                // return results to android as they come in ...
                                                android_return_search_result(jni,buffer);
#endif
                                                g_free(buffer);
                                        }
                                }
                }
        }

        //dbg(0,"return 2\n");
        return result_list;
}

static GList *
search_address__street(GList *result_list, struct search_list *sl, GList *phrases, GList *exclude1, GList *exclude2, GList *exclude3, int partial, struct jni_object *jni)
{
        //dbg(0,"enter\n");

        struct search_list_result *slr = NULL;
        GList *tmp = phrases;
        int count = 0;
        struct coord_geo g;
        struct coord c;
        struct attr attr2;

        struct item *save_item;
        int save_level;
        int save_last_result_valid;

        while ((slr = search_list_get_result(sl)))
        {
                char *buffer;
                char *buffer2;

                if (offline_search_break_searching == 1)
                {
                        break;
                }

                if (slr->street)
                {
                        // coords of result
                        c.x = slr->street->common.c->x;
                        c.y = slr->street->common.c->y;
                        transform_to_geo(slr->street->common.c->pro, &c, &g);

                        // STR -> street
                        // return a string like: "STR:H1111L5555:16.766:-48.76:full address name is at the end"
                        // ca. 9 chars : ca. 9 chars : max. 100 max. 100 max. 100 chars -> this sould be max. about 320 chars long
                        if (slr->town->common.postal == NULL)
                        {
                                buffer = g_strdup_printf("STR:H%dL%d:%f:%f:%.101s,%.101s, %.101s", slr->street->common.item.id_hi, slr->street->common.item.id_lo, g.lat, g.lng, slr->country->name, slr->town->common.town_name, slr->street->name);
                        }
                        else
                        {
                                buffer = g_strdup_printf("STR:H%dL%d:%f:%f:%.101s,%.7s %.101s, %.101s", slr->street->common.item.id_hi, slr->street->common.item.id_lo, g.lat, g.lng, slr->country->name, slr->town->common.postal, slr->town->common.town_name, slr->street->name);
                        }
                        // deactivated now * result_list=g_list_prepend(result_list,g_strdup(buffer));

                        //dbg(0,"res=%s\n",buffer);

#ifdef HAVE_API_ANDROID
                        // return results to android as they come in ...
                        android_return_search_result(jni,buffer);
#endif
                        count++;

                        buffer2 = g_strdup_printf("%s", slr->street->name);
                        //dbg(0,"b2:%s\n",buffer2);


                        save_item = sl->item;
                        save_level = sl->level;
                        save_last_result_valid = sl->last_result_valid;

#if 1
                        // put words back to start!!
                        tmp = phrases;
                        while (tmp)
                        {
                                //dbg(0,"s0=%s\n",tmp->data);
                                if (tmp != exclude1 && tmp != exclude2 && tmp != exclude3)
                                {
                                        //dbg(0,"s=%s\n",tmp->data);

                                        attr2.type = attr_house_number;
                                        attr2.u.str = tmp->data;
                                        search_list_search(sl, &attr2, partial);

                                        result_list = search_address_housenumber_real(result_list, sl, buffer2, phrases, exclude1, exclude2, exclude3, partial, jni);
                                }
                                tmp = g_list_next(tmp);
                        }
#endif

                        // restore again
                        sl->item = save_item;
                        sl->level = save_level;
                        sl->last_result_valid = save_last_result_valid;

                }

                if (buffer2)
                {
                        g_free(buffer2);
                }

                if (buffer)
                {
                        g_free(buffer);
                }
        }

        //dbg(0,"return 2\n");
        return result_list;
}

static GList *
search_address__town(GList *result_list, struct search_list *sl, GList *phrases, GList *exclude1, GList *exclude2, int partial, struct jni_object *jni)
{
        //dbg(0,"enter\n");
        struct search_list_result *slr;
        GList *tmp = phrases;
        int count = 0;
        struct coord_geo g;
        struct coord c;
        struct attr attr;
        struct attr attrx;
        // struct search_list *sl2=search_list_new(sl->ms);
        struct item *save_item;
        int save_level;
        int save_last_result_valid;
        // int first=1;

        while ((slr = search_list_get_result(sl)))
        {
                char *buffer;

                if (offline_search_break_searching == 1)
                {
                        break;
                }

                // coords of result
                c.x = slr->town->common.c->x;
                c.y = slr->town->common.c->y;
                transform_to_geo(slr->town->common.c->pro, &c, &g);

                // TWN -> town
                if (slr->town->common.postal == NULL)
                {
                        buffer = g_strdup_printf("TWN:H%dL%d:%f:%f:%.101s,%.101s", slr->town->common.item.id_hi, slr->town->common.item.id_lo, g.lat, g.lng, slr->country->name, slr->town->common.town_name);
                }
                else
                {
                        buffer = g_strdup_printf("TWN:H%dL%d:%f:%f:%.101s,%.7s %.101s", slr->town->common.item.id_hi, slr->town->common.item.id_lo, g.lat, g.lng, slr->country->name, slr->town->common.postal, slr->town->common.town_name);
                }

                //dbg(0,"**res=%s\n",buffer);

                // deactivated now * result_list=g_list_prepend(result_list,g_strdup(buffer));
#ifdef HAVE_API_ANDROID
                // return results to android as they come in ...
                android_return_search_result(jni,buffer);
#endif

                count++;
                if (buffer)
                        g_free(buffer);

                save_item = sl->item;
                save_level = sl->level;
                save_last_result_valid = sl->last_result_valid;

                // put words back to start!!
                tmp = phrases;

                while (tmp)
                {
                        if (tmp != exclude1 && tmp != exclude2)
                        {
                                //dbg(0,"s=%s\n",tmp->data);
                                attr.type = attr_street_name;
                                attr.u.str = tmp->data;
                                search_list_search(sl, &attr, partial);
                                result_list = search_address__street(result_list, sl, phrases, exclude1, exclude2, tmp, partial, jni);
                        }
                        tmp = g_list_next(tmp);
                }

                // restore again
                sl->item = save_item;
                sl->level = save_level;
                sl->last_result_valid = save_last_result_valid;
        }

        //dbg(0,"return 2\n");
        return result_list;
}

static GList *
search_address__country(GList *result_list, struct search_list *sl, GList *phrases, GList *exclude, int partial, struct jni_object *jni)
{
        GList *tmp = phrases;
        int count = 0;
        struct attr attr;
        struct search_list_result *slr;
        //dbg(0,"enter\n");

        while ((slr = search_list_get_result(sl)))
        {
                //dbg(0,"1 slr=%p\n",slr->country);
                //dbg(0,"2 slr=%s\n",slr->country->name);
                //dbg(0,"3 slr=%s\n",slr->country->iso2);
                count++;
        }
        //dbg(0,"count %d\n",count);
        if (!count)
        {
                //dbg(0,"return 1");
                return result_list;
        }

        while (tmp)
        {
                if (tmp != exclude)
                {
                        //dbg(0,"Is=%s\n",tmp->data);
                        attr.type = attr_town_or_district_name;
                        attr.u.str = tmp->data;
                        search_list_search(sl, &attr, partial);
                        result_list = search_address__town(result_list, sl, phrases, exclude, tmp, partial, jni);
                }
                //else
                //{
                //dbg(0,"Xs=%s\n",tmp->data);
                //}
                tmp = g_list_next(tmp);
        }
        //dbg(0,"return 2");
        return result_list;
}

struct country2
{
        int id;
        char *car;
        char *iso2;
        char *iso3;
        char *name;
};

static struct country2 all_country_list[] =
{
{ 20, "AND", "AD", "AND", /* 020 */"Andorra" },
{ 784, "UAE", "AE", "ARE", /* 784 */
"United Arab Emirates" },
{ 4, "AFG", "AF", "AFG", /* 004 */"Afghanistan" },
{ 28, "AG", "AG", "ATG", /* 028 */"Antigua and Barbuda" },
{ 660, NULL, "AI", "AIA", /* 660 */"Anguilla" },
{ 8, "AL", "AL", "ALB", /* 008 */"Albania" },
{ 51, "ARM", "AM", "ARM", /* 051 */"Armenia" },
{ 530, "NA", "AN", "ANT", /* 530 */
"Netherlands Antilles" },
{ 24, "ANG", "AO", "AGO", /* 024 */"Angola" },
{ 10, NULL, "AQ", "ATA", /* 010 */"Antarctica" },
{ 32, "RA", "AR", "ARG", /* 032 */"Argentina" },
{ 16, NULL, "AS", "ASM", /* 016 */"American Samoa" },
{ 40, "A", "AT", "AUT", /* 040 */"Austria" },
{ 36, "AUS", "AU", "AUS", /* 036 */"Australia" },
{ 533, "ARU", "AW", "ABW", /* 533 */"Aruba" },
{ 248, "AX", "AX", "ALA", /* 248 */"Aland Islands" },
{ 31, "AZ", "AZ", "AZE", /* 031 */"Azerbaijan" },
{ 70, "BiH", "BA", "BIH", /* 070 */
"Bosnia and Herzegovina" },
{ 52, "BDS", "BB", "BRB", /* 052 */"Barbados" },
{ 50, "BD", "BD", "BGD", /* 050 */"Bangladesh" },
{ 56, "B", "BE", "BEL", /* 056 */"Belgium" },
{ 854, "BF", "BF", "BFA", /* 854 */"Burkina Faso" },
{ 100, "BG", "BG", "BGR", /* 100 */"Bulgaria" },
{ 48, "BRN", "BH", "BHR", /* 048 */"Bahrain" },
{ 108, "RU", "BI", "BDI", /* 108 */"Burundi" },
{ 204, "BJ", "BJ", "BEN", /* 204 */"Benin" },
{ 652, NULL, "BL", "BLM", /* 652 */"Saint Barthelemy" },
{ 60, NULL, "BM", "BMU", /* 060 */"Bermuda" },
{ 96, "BRU", "BN", "BRN", /* 096 */"Brunei Darussalam" },
{ 68, "BOL", "BO", "BOL", /* 068 */"Bolivia" },
{ 76, "BR", "BR", "BRA", /* 076 */"Brazil" },
{ 44, "BS", "BS", "BHS", /* 044 */"Bahamas" },
{ 64, "BHT", "BT", "BTN", /* 064 */"Bhutan" },
{ 74, NULL, "BV", "BVT", /* 074 */"Bouvet Island" },
{ 72, "RB", "BW", "BWA", /* 072 */"Botswana" },
{ 112, "BY", "BY", "BLR", /* 112 */"Belarus" },
{ 84, "BZ", "BZ", "BLZ", /* 084 */"Belize" },
{ 124, "CDN", "CA", "CAN", /* 124 */"Canada" },
{ 166, NULL, "CC", "CCK", /* 166 */
"Cocos (Keeling) Islands" },
{ 180, "CGO", "CD", "COD", /* 180 */
"Congo, Democratic Republic of the" },
{ 140, "RCA", "CF", "CAF", /* 140 */
"Central African Republic" },
{ 178, NULL, "CG", "COG", /* 178 */"Congo" },
{ 756, "CH", "CH", "CHE", /* 756 */"Switzerland" },
{ 384, "CI", "CI", "CIV", /* 384 */"Cote d'Ivoire" },
{ 184, NULL, "CK", "COK", /* 184 */"Cook Islands" },
{ 152, "RCH", "CL", "CHL", /* 152 */"Chile" },
{ 120, "CAM", "CM", "CMR", /* 120 */"Cameroon" },
{ 156, "RC", "CN", "CHN", /* 156 */"China" },
{ 170, "CO", "CO", "COL", /* 170 */"Colombia" },
{ 188, "CR", "CR", "CRI", /* 188 */"Costa Rica" },
{ 192, "C", "CU", "CUB", /* 192 */"Cuba" },
{ 132, "CV", "CV", "CPV", /* 132 */"Cape Verde" },
{ 162, NULL, "CX", "CXR", /* 162 */"Christmas Island" },
{ 196, "CY", "CY", "CYP", /* 196 */"Cyprus" },
{ 203, "CZ", "CZ", "CZE", /* 203 */"Czech Republic" },
{ 276, "D", "DE", "DEU", /* 276 */"Germany" },
{ 262, "DJI", "DJ", "DJI", /* 262 */"Djibouti" },
{ 208, "DK", "DK", "DNK", /* 208 */"Denmark" },
{ 212, "WD", "DM", "DMA", /* 212 */"Dominica" },
{ 214, "DOM", "DO", "DOM", /* 214 */
"Dominican Republic" },
{ 12, "DZ", "DZ", "DZA", /* 012 */"Algeria" },
{ 218, "EC", "EC", "ECU", /* 218 */"Ecuador" },
{ 233, "EST", "EE", "EST", /* 233 */"Estonia" },
{ 818, "ET", "EG", "EGY", /* 818 */"Egypt" },
{ 732, "WSA", "EH", "ESH", /* 732 */"Western Sahara" },
{ 232, "ER", "ER", "ERI", /* 232 */"Eritrea" },
{ 724, "E", "ES", "ESP", /* 724 */"Spain" },
{ 231, "ETH", "ET", "ETH", /* 231 */"Ethiopia" },
{ 246, "FIN", "FI", "FIN", /* 246 */"Finland" },
{ 242, "FJI", "FJ", "FJI", /* 242 */"Fiji" },
{ 238, NULL, "FK", "FLK", /* 238 */
"Falkland Islands (Malvinas)" },
{ 583, "FSM", "FM", "FSM", /* 583 */
"Micronesia, Federated States of" },
{ 234, "FO", "FO", "FRO", /* 234 */"Faroe Islands" },
{ 250, "F", "FR", "FRA", /* 250 */"France" },
{ 266, "G", "GA", "GAB", /* 266 */"Gabon" },
{ 826, "GB", "GB", "GBR", /* 826 */"United Kingdom" },
{ 308, "WG", "GD", "GRD", /* 308 */"Grenada" },
{ 268, "GE", "GE", "GEO", /* 268 */"Georgia" },
{ 254, NULL, "GF", "GUF", /* 254 */"French Guiana" },
{ 831, NULL, "GG", "GGY", /* 831 */"Guernsey" },
{ 288, "GH", "GH", "GHA", /* 288 */"Ghana" },
{ 292, "GBZ", "GI", "GIB", /* 292 */"Gibraltar" },
{ 304, "KN", "GL", "GRL", /* 304 */"Greenland" },
{ 270, "WAG", "GM", "GMB", /* 270 */"Gambia" },
{ 324, "RG", "GN", "GIN", /* 324 */"Guinea" },
{ 312, NULL, "GP", "GLP", /* 312 */"Guadeloupe" },
{ 226, "GQ", "GQ", "GNQ", /* 226 */"Equatorial Guinea" },
{ 300, "GR", "GR", "GRC", /* 300 */"Greece" },
{ 239, NULL, "GS", "SGS", /* 239 */
"South Georgia and the South Sandwich Islands" },
{ 320, "GCA", "GT", "GTM", /* 320 */"Guatemala" },
{ 316, NULL, "GU", "GUM", /* 316 */"Guam" },
{ 624, "GUB", "GW", "GNB", /* 624 */"Guinea-Bissau" },
{ 328, "GUY", "GY", "GUY", /* 328 */"Guyana" },
{ 344, "HK", "HK", "HKG", /* 344 */"Hong Kong" },
{ 334, NULL, "HM", "HMD", /* 334 */
"Heard Island and McDonald Islands" },
{ 340, "HN", "HN", "HND", /* 340 */"Honduras" },
{ 191, "HR", "HR", "HRV", /* 191 */"Croatia" },
{ 332, "RH", "HT", "HTI", /* 332 */"Haiti" },
{ 348, "H", "HU", "HUN", /* 348 */"Hungary" },
{ 360, "RI", "ID", "IDN", /* 360 */"Indonesia" },
{ 372, "IRL", "IE", "IRL", /* 372 */"Ireland" },
{ 376, "IL", "IL", "ISR", /* 376 */"Israel" },
{ 833, NULL, "IM", "IMN", /* 833 */"Isle of Man" },
{ 356, "IND", "IN", "IND", /* 356 */"India" },
{ 86, NULL, "IO", "IOT", /* 086 */
"British Indian Ocean Territory" },
{ 368, "IRQ", "IQ", "IRQ", /* 368 */"Iraq" },
{ 364, "IR", "IR", "IRN", /* 364 */
"Iran, Islamic Republic of" },
{ 352, "IS", "IS", "ISL", /* 352 */"Iceland" },
{ 380, "I", "IT", "ITA", /* 380 */"Italy" },
{ 832, NULL, "JE", "JEY", /* 832 */"Jersey" },
{ 388, "JA", "JM", "JAM", /* 388 */"Jamaica" },
{ 400, "JOR", "JO", "JOR", /* 400 */"Jordan" },
{ 392, "J", "JP", "JPN", /* 392 */"Japan" },
{ 404, "EAK", "KE", "KEN", /* 404 */"Kenya" },
{ 417, "KS", "KG", "KGZ", /* 417 */"Kyrgyzstan" },
{ 116, "K", "KH", "KHM", /* 116 */"Cambodia" },
{ 296, "KIR", "KI", "KIR", /* 296 */"Kiribati" },
{ 174, "COM", "KM", "COM", /* 174 */"Comoros" },
{ 659, "KAN", "KN", "KNA", /* 659 */
"Saint Kitts and Nevis" },
{ 408, "KP", "KP", "PRK", /* 408 */
"Korea, Democratic People's Republic of" },
{ 410, "ROK", "KR", "KOR", /* 410 */
"Korea, Republic of" },
{ 414, "KWT", "KW", "KWT", /* 414 */"Kuwait" },
{ 136, NULL, "KY", "CYM", /* 136 */"Cayman Islands" },
{ 398, "KZ", "KZ", "KAZ", /* 398 */"Kazakhstan" },
{ 418, "LAO", "LA", "LAO", /* 418 */
"Lao People's Democratic Republic" },
{ 422, "RL", "LB", "LBN", /* 422 */"Lebanon" },
{ 662, "WL", "LC", "LCA", /* 662 */"Saint Lucia" },
{ 438, "FL", "LI", "LIE", /* 438 */"Liechtenstein" },
{ 144, "CL", "LK", "LKA", /* 144 */"Sri Lanka" },
{ 430, "LB", "LR", "LBR", /* 430 */"Liberia" },
{ 426, "LS", "LS", "LSO", /* 426 */"Lesotho" },
{ 440, "LT", "LT", "LTU", /* 440 */"Lithuania" },
{ 442, "L", "LU", "LUX", /* 442 */"Luxembourg" },
{ 428, "LV", "LV", "LVA", /* 428 */"Latvia" },
{ 434, "LAR", "LY", "LBY", /* 434 */
"Libyan Arab Jamahiriya" },
{ 504, "MA", "MA", "MAR", /* 504 */"Morocco" },
{ 492, "MC", "MC", "MCO", /* 492 */"Monaco" },
{ 498, "MD", "MD", "MDA", /* 498 */
"Moldova, Republic of" },
{ 499, "MNE", "ME", "MNE", /* 499 */"Montenegro" },
{ 663, NULL, "MF", "MAF", /* 663 */
"Saint Martin (French part)" },
{ 450, "RM", "MG", "MDG", /* 450 */"Madagascar" },
{ 584, "MH", "MH", "MHL", /* 584 */"Marshall Islands" },
{ 807, "MK", "MK", "MKD", /* 807 */
"Macedonia, the former Yugoslav Republic of" },
{ 466, "RMM", "ML", "MLI", /* 466 */"Mali" },
{ 104, "MYA", "MM", "MMR", /* 104 */"Myanmar" },
{ 496, "MGL", "MN", "MNG", /* 496 */"Mongolia" },
{ 446, NULL, "MO", "MAC", /* 446 */"Macao" },
{ 580, NULL, "MP", "MNP", /* 580 */
"Northern Mariana Islands" },
{ 474, NULL, "MQ", "MTQ", /* 474 */"Martinique" },
{ 478, "RIM", "MR", "MRT", /* 478 */"Mauritania" },
{ 500, NULL, "MS", "MSR", /* 500 */"Montserrat" },
{ 470, "M", "MT", "MLT", /* 470 */"Malta" },
{ 480, "MS", "MU", "MUS", /* 480 */"Mauritius" },
{ 462, "MV", "MV", "MDV", /* 462 */"Maldives" },
{ 454, "MW", "MW", "MWI", /* 454 */"Malawi" },
{ 484, "MEX", "MX", "MEX", /* 484 */"Mexico" },
{ 458, "MAL", "MY", "MYS", /* 458 */"Malaysia" },
{ 508, "MOC", "MZ", "MOZ", /* 508 */"Mozambique" },
{ 516, "NAM", "NA", "NAM", /* 516 */"Namibia" },
{ 540, "NCL", "NC", "NCL", /* 540 */"New Caledonia" },
{ 562, "RN", "NE", "NER", /* 562 */"Niger" },
{ 574, NULL, "NF", "NFK", /* 574 */"Norfolk Island" },
{ 566, "NGR", "NG", "NGA", /* 566 */"Nigeria" },
{ 558, "NIC", "NI", "NIC", /* 558 */"Nicaragua" },
{ 528, "NL", "NL", "NLD", /* 528 */"Netherlands" },
{ 578, "N", "NO", "NOR", /* 578 */"Norway" },
{ 524, "NEP", "NP", "NPL", /* 524 */"Nepal" },
{ 520, "NAU", "NR", "NRU", /* 520 */"Nauru" },
{ 570, NULL, "NU", "NIU", /* 570 */"Niue" },
{ 554, "NZ", "NZ", "NZL", /* 554 */"New Zealand" },
{ 512, "OM", "OM", "OMN", /* 512 */"Oman" },
{ 591, "PA", "PA", "PAN", /* 591 */"Panama" },
{ 604, "PE", "PE", "PER", /* 604 */"Peru" },
{ 258, NULL, "PF", "PYF", /* 258 */"French Polynesia" },
{ 598, "PNG", "PG", "PNG", /* 598 */"Papua New Guinea" },
{ 608, "RP", "PH", "PHL", /* 608 */"Philippines" },
{ 586, "PK", "PK", "PAK", /* 586 */"Pakistan" },
{ 616, "PL", "PL", "POL", /* 616 */"Poland" },
{ 666, NULL, "PM", "SPM", /* 666 */
"Saint Pierre and Miquelon" },
{ 612, NULL, "PN", "PCN", /* 612 */"Pitcairn" },
{ 630, "PRI", "PR", "PRI", /* 630 */"Puerto Rico" },
{ 275, "AUT", "PS", "PSE", /* 275 */
"Palestinian Territory, Occupied" },
{ 620, "P", "PT", "PRT", /* 620 */"Portugal" },
{ 585, "PAL", "PW", "PLW", /* 585 */"Palau" },
{ 600, "PY", "PY", "PRY", /* 600 */"Paraguay" },
{ 634, "Q", "QA", "QAT", /* 634 */"Qatar" },
{ 638, NULL, "RE", "REU", /* 638 */"Reunion" },
{ 642, "RO", "RO", "ROU", /* 642 */"Romania" },
{ 688, "SRB", "RS", "SRB", /* 688 */"Serbia" },
{ 643, "RUS", "RU", "RUS", /* 643 */
"Russian Federation" },
{ 646, "RWA", "RW", "RWA", /* 646 */"Rwanda" },
{ 682, "KSA", "SA", "SAU", /* 682 */"Saudi Arabia" },
{ 90, "SOL", "SB", "SLB", /* 090 */"Solomon Islands" },
{ 690, "SY", "SC", "SYC", /* 690 */"Seychelles" },
{ 736, "SUD", "SD", "SDN", /* 736 */"Sudan" },
{ 752, "S", "SE", "SWE", /* 752 */"Sweden" },
{ 702, "SGP", "SG", "SGP", /* 702 */"Singapore" },
{ 654, NULL, "SH", "SHN", /* 654 */"Saint Helena" },
{ 705, "SLO", "SI", "SVN", /* 705 */"Slovenia" },
{ 744, NULL, "SJ", "SJM", /* 744 */
"Svalbard and Jan Mayen" },
{ 703, "SK", "SK", "SVK", /* 703 */"Slovakia" },
{ 694, "WAL", "SL", "SLE", /* 694 */"Sierra Leone" },
{ 674, "RSM", "SM", "SMR", /* 674 */"San Marino" },
{ 686, "SN", "SN", "SEN", /* 686 */"Senegal" },
{ 706, "SO", "SO", "SOM", /* 706 */"Somalia" },
{ 740, "SME", "SR", "SUR", /* 740 */"Suriname" },
{ 678, "STP", "ST", "STP", /* 678 */
"Sao Tome and Principe" },
{ 222, "ES", "SV", "SLV", /* 222 */"El Salvador" },
{ 760, "SYR", "SY", "SYR", /* 760 */
"Syrian Arab Republic" },
{ 748, "SD", "SZ", "SWZ", /* 748 */"Swaziland" },
{ 796, NULL, "TC", "TCA", /* 796 */
"Turks and Caicos Islands" },
{ 148, "TD", "TD", "TCD", /* 148 */"Chad" },
{ 260, "ARK", "TF", "ATF", /* 260 */
"French Southern Territories" },
{ 768, "RT", "TG", "TGO", /* 768 */"Togo" },
{ 764, "T", "TH", "THA", /* 764 */"Thailand" },
{ 762, "TJ", "TJ", "TJK", /* 762 */"Tajikistan" },
{ 772, NULL, "TK", "TKL", /* 772 */"Tokelau" },
{ 626, "TL", "TL", "TLS", /* 626 */"Timor-Leste" },
{ 795, "TM", "TM", "TKM", /* 795 */"Turkmenistan" },
{ 788, "TN", "TN", "TUN", /* 788 */"Tunisia" },
{ 776, "TON", "TO", "TON", /* 776 */"Tonga" },
{ 792, "TR", "TR", "TUR", /* 792 */"Turkey" },
{ 780, "TT", "TT", "TTO", /* 780 */
"Trinidad and Tobago" },
{ 798, "TUV", "TV", "TUV", /* 798 */"Tuvalu" },
{ 158, NULL, "TW", "TWN", /* 158 */
"Taiwan, Province of China" },
{ 834, "EAT", "TZ", "TZA", /* 834 */
"Tanzania, United Republic of" },
{ 804, "UA", "UA", "UKR", /* 804 */"Ukraine" },
{ 800, "EAU", "UG", "UGA", /* 800 */"Uganda" },
{ 581, NULL, "UM", "UMI", /* 581 */
"United States Minor Outlying Islands" },
{ 840, "USA", "US", "USA", /* 840 */"United States" },
{ 858, "ROU", "UY", "URY", /* 858 */"Uruguay" },
{ 860, "UZ", "UZ", "UZB", /* 860 */"Uzbekistan" },
{ 336, "SCV", "VA", "VAT", /* 336 */
"Holy See (Vatican City State)" },
{ 670, "WV", "VC", "VCT", /* 670 */"Saint Vincent and the Grenadines" },
{ 862, "YV", "VE", "VEN", /* 862 */"Venezuela" },
{ 92, NULL, "VG", "VGB", /* 092 */ "Virgin Islands, British" },
{ 850, NULL, "VI", "VIR", /* 850 */ "Virgin Islands, U.S." },
{ 704, "VN", "VN", "VNM", /* 704 */"Viet Nam" },
{ 548, "VAN", "VU", "VUT", /* 548 */"Vanuatu" },
{ 876, NULL, "WF", "WLF", /* 876 */"Wallis and Futuna" },
{ 882, "WS", "WS", "WSM", /* 882 */"Samoa" },
{ 887, "YAR", "YE", "YEM", /* 887 */"Yemen" },
{ 175, NULL, "YT", "MYT", /* 175 */"Mayotte" },
{ 710, "ZA", "ZA", "ZAF", /* 710 */"South Africa" },
{ 894, "Z", "ZM", "ZMB", /* 894 */"Zambia" },
{ 716, "ZW", "ZW", "ZWE", /* 716 */"Zimbabwe" },
{ 999, "*", "*", "*", /* 999 */"Unknown" }, };

static int ascii_cmp_local(char *name, char *match, int partial)
{
        char *s1 = linguistics_casefold(name);
        char *s2 = linguistics_casefold(match);
        int ret = linguistics_compare(s1, s2, partial);
        g_free(s1);
        g_free(s2);
        return ret;
}

struct navit *global_navit;

void search_full_world(char *addr, int partial, int search_order, struct jni_object *jni, struct coord_geo *search_center, int search_radius)
{
        struct item *item;
        struct map_rect *mr = NULL;
        struct mapset *ms;
        struct mapset_handle *msh;
        struct map* map = NULL;
        struct attr map_name_attr;
        struct attr attr;

        char *str = search_fix_spaces(addr);
        GList *phrases = search_split_phrases(str);
        GList *phrases_first;
        phrases_first = phrases;

        ms = global_navit->mapsets->data;
        msh = mapset_open(ms);

        struct pcoord center99;
        int search_radius_this = 0;
        dbg(0, "in lat=%f,lng=%f\n", search_center->lat, search_center->lng);
        if ((search_center->lat == 0) && (search_center->lng == 0))
        {
                center99.x = 0;
                center99.y = 0;
                search_radius_this = 21000000;
        }
        else
        {
                struct coord c99;
                transform_from_geo(projection_mg, search_center, &c99);
                center99.x = c99.x;
                center99.y = c99.y;
                search_radius_this = search_radius;
        }
        dbg(0, "out x=%d,y=%d,r=%d\n", center99.x, center99.y, search_radius_this);

        struct map_selection *sel = map_selection_rect_new(&center99, search_radius_this, search_order);
        sel->range.min = type_town_label;
        sel->range.max = type_area;

        while (msh && (map = mapset_next(msh, 0)))
        {
                if (map_get_attr(map, attr_name, &map_name_attr, NULL))
                {
                        if (strncmp("_ms_sdcard_map:", map_name_attr.u.str, 15) == 0)
                        {
                                if (strncmp("_ms_sdcard_map:/sdcard/zanavi/maps/navitmap", map_name_attr.u.str, 38) == 0)
                                {
                                        // its an sdcard map
                                        //dbg(0,"map name=%s",map_name_attr.u.str);
                                        // mr=map_rect_new(map, NULL);
                                        mr = map_rect_new(map, sel);
                                        if (mr)
                                        {
                                                char *streetname_last = NULL;

                                                while ((item = map_rect_get_item(mr)))
                                                {
                                                        if ((item_is_town(*item)) || (item_is_district(*item)))
                                                        {
                                                                struct search_list_town *p = NULL;

                                                                if (item_attr_get(item, attr_town_name, &attr))
                                                                {
                                                                        p = search_list_town_new(item);
                                                                        char *buffer = NULL;
                                                                        // coords of result
                                                                        struct coord_geo g;
                                                                        struct coord c;
                                                                        c.x = p->common.c->x;
                                                                        c.y = p->common.c->y;
                                                                        int calc_geo = 0;

                                                                        // dbg(0,"town name=%s\n", attr.u.str);

                                                                        phrases = phrases_first;
                                                                        while (phrases)
                                                                        {
                                                                                if (!ascii_cmp_local(attr.u.str, phrases->data, partial))
                                                                                {
                                                                                        // dbg(0,"matched town name=%s want=%s\n", attr.u.str, phrases->data);
                                                                                        if (calc_geo == 0)
                                                                                        {
                                                                                                transform_to_geo(p->common.c->pro, &c, &g);
                                                                                                // TWN -> town
                                                                                                calc_geo = 1;
                                                                                        }
                                                                                        if (p->common.postal == NULL)
                                                                                        {
                                                                                                buffer = g_strdup_printf("TWN:H%dL%d:%f:%f:%.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, p->common.town_name);
                                                                                        }
                                                                                        else
                                                                                        {
                                                                                                buffer = g_strdup_printf("TWN:H%dL%d:%f:%f:%.7s %.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, p->common.postal, p->common.town_name);
                                                                                        }
#ifdef HAVE_API_ANDROID
                                                                                        // return results to android as they come in ...
                                                                                        android_return_search_result(jni,buffer);
#endif
                                                                                }
                                                                                phrases = g_list_next(phrases);

                                                                        }
                                                                        if (buffer)
                                                                        {
                                                                                g_free(buffer);
                                                                        }
                                                                        search_list_town_destroy(p);
                                                                }

                                                                if (item_attr_get(item, attr_town_name_match, &attr))
                                                                {
                                                                        p = search_list_town_new(item);
                                                                        char *buffer = NULL;
                                                                        // coords of result
                                                                        struct coord_geo g;
                                                                        struct coord c;
                                                                        c.x = p->common.c->x;
                                                                        c.y = p->common.c->y;
                                                                        int calc_geo = 0;

                                                                        // dbg(0,"town name=%s\n", attr.u.str);

                                                                        phrases = phrases_first;
                                                                        while (phrases)
                                                                        {
                                                                                if (!ascii_cmp_local(attr.u.str, phrases->data, partial))
                                                                                {
                                                                                        // dbg(0,"matched town name=%s want=%s\n", attr.u.str, phrases->data);
                                                                                        if (calc_geo == 0)
                                                                                        {
                                                                                                transform_to_geo(p->common.c->pro, &c, &g);
                                                                                                // TWN -> town
                                                                                                calc_geo = 1;
                                                                                        }
                                                                                        if (p->common.postal == NULL)
                                                                                        {
                                                                                                buffer = g_strdup_printf("TWN:H%dL%d:%f:%f:%.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, p->common.town_name);
                                                                                        }
                                                                                        else
                                                                                        {
                                                                                                buffer = g_strdup_printf("TWN:H%dL%d:%f:%f:%.7s %.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, p->common.postal, p->common.town_name);
                                                                                        }
#ifdef HAVE_API_ANDROID
                                                                                        // return results to android as they come in ...
                                                                                        android_return_search_result(jni,buffer);
#endif
                                                                                }
                                                                                phrases = g_list_next(phrases);

                                                                        }
                                                                        if (buffer)
                                                                        {
                                                                                g_free(buffer);
                                                                        }
                                                                        search_list_town_destroy(p);
                                                                }
                                                        }
                                                        else if (item_is_street(*item))
                                                        {

                                                                struct search_list_street *p = NULL;

                                                                if (item_attr_get(item, attr_label, &attr))
                                                                {
                                                                        // dbg(0,"street1=%s\n",map_convert_string(item->map, attr.u.str));
                                                                        if ((streetname_last == NULL) || (strcmp(streetname_last, attr.u.str) != 0))
                                                                        {
                                                                                // dbg(0,"street2=%s\n",map_convert_string(item->map, attr.u.str));
                                                                                streetname_last = g_strdup_printf("%s", attr.u.str);

                                                                                p = search_list_street_new(item);
                                                                                char *buffer = NULL;
                                                                                // coords of result
                                                                                struct coord_geo g;
                                                                                struct coord c;
                                                                                c.x = p->common.c->x;
                                                                                c.y = p->common.c->y;
                                                                                int calc_geo = 0;

                                                                                phrases = phrases_first;
                                                                                while (phrases)
                                                                                {
                                                                                        if (!ascii_cmp_local(attr.u.str, phrases->data, partial))
                                                                                        {
                                                                                                if (calc_geo == 0)
                                                                                                {
                                                                                                        transform_to_geo(p->common.c->pro, &c, &g);
                                                                                                        calc_geo = 1;
                                                                                                }
                                                                                                if (p->common.postal == NULL)
                                                                                                {
                                                                                                        buffer = g_strdup_printf("STR:H%dL%d:%f:%f:%.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, attr.u.str);
                                                                                                }
                                                                                                else
                                                                                                {
                                                                                                        buffer = g_strdup_printf("STR:H%dL%d:%f:%f:%.7s %.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, p->common.postal, attr.u.str);
                                                                                                }
                                                                                                //dbg(0,"street3=%s\n",buffer);
#ifdef HAVE_API_ANDROID
                                                                                                // return results to android as they come in ...
                                                                                                android_return_search_result(jni,buffer);
#endif
                                                                                        }
                                                                                        phrases = g_list_next(phrases);
                                                                                }
                                                                                if (buffer)
                                                                                {
                                                                                        g_free(buffer);
                                                                                }
                                                                                search_list_street_destroy(p);
                                                                        }
                                                                }

                                                                if (item_attr_get(item, attr_street_name_match, &attr))
                                                                {
                                                                        //dbg(0,"street systematic=%s\n",map_convert_string(item->map, attr.u.str));

                                                                        p = search_list_street_new(item);
                                                                        char *buffer = NULL;
                                                                        // coords of result
                                                                        struct coord_geo g;
                                                                        struct coord c;
                                                                        c.x = p->common.c->x;
                                                                        c.y = p->common.c->y;
                                                                        int calc_geo = 0;

                                                                        phrases = phrases_first;
                                                                        while (phrases)
                                                                        {
                                                                                if (!ascii_cmp_local(attr.u.str, phrases->data, partial))
                                                                                {
                                                                                        if (calc_geo == 0)
                                                                                        {
                                                                                                transform_to_geo(p->common.c->pro, &c, &g);
                                                                                                calc_geo = 1;
                                                                                        }
                                                                                        if (p->common.postal == NULL)
                                                                                        {
                                                                                                buffer = g_strdup_printf("STR:H%dL%d:%f:%f:%.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, attr.u.str);
                                                                                        }
                                                                                        else
                                                                                        {
                                                                                                buffer = g_strdup_printf("STR:H%dL%d:%f:%f:%.7s %.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, p->common.postal, attr.u.str);
                                                                                        }
#ifdef HAVE_API_ANDROID
                                                                                        // return results to android as they come in ...
                                                                                        android_return_search_result(jni,buffer);
#endif
                                                                                }
                                                                                phrases = g_list_next(phrases);
                                                                        }
                                                                        if (buffer)
                                                                        {
                                                                                g_free(buffer);
                                                                        }
                                                                        search_list_street_destroy(p);

                                                                }

                                                                if (item_attr_get(item, attr_street_name_systematic, &attr))
                                                                {
                                                                        //dbg(0,"street systematic=%s\n",map_convert_string(item->map, attr.u.str));

                                                                        p = search_list_street_new(item);
                                                                        char *buffer = NULL;
                                                                        // coords of result
                                                                        struct coord_geo g;
                                                                        struct coord c;
                                                                        c.x = p->common.c->x;
                                                                        c.y = p->common.c->y;
                                                                        int calc_geo = 0;

                                                                        phrases = phrases_first;
                                                                        while (phrases)
                                                                        {
                                                                                if (!ascii_cmp_local(attr.u.str, phrases->data, partial))
                                                                                {
                                                                                        if (calc_geo == 0)
                                                                                        {
                                                                                                transform_to_geo(p->common.c->pro, &c, &g);
                                                                                                calc_geo = 1;
                                                                                        }
                                                                                        if (p->common.postal == NULL)
                                                                                        {
                                                                                                buffer = g_strdup_printf("STR:H%dL%d:%f:%f:%.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, attr.u.str);
                                                                                        }
                                                                                        else
                                                                                        {
                                                                                                buffer = g_strdup_printf("STR:H%dL%d:%f:%f:%.7s %.101s", p->common.item.id_hi, p->common.item.id_lo, g.lat, g.lng, p->common.postal, attr.u.str);
                                                                                        }
#ifdef HAVE_API_ANDROID
                                                                                        // return results to android as they come in ...
                                                                                        android_return_search_result(jni,buffer);
#endif
                                                                                }
                                                                                phrases = g_list_next(phrases);
                                                                        }
                                                                        if (buffer)
                                                                        {
                                                                                g_free(buffer);
                                                                        }
                                                                        search_list_street_destroy(p);

                                                                }
                                                        }
                                                }
                                                g_free(streetname_last);
                                                map_rect_destroy(mr);
                                        }
                                }
                        }
                }
        }

        map_selection_destroy(sel);

        if (phrases)
        {
                g_list_free(phrases);
        }
        g_free(str);

        mapset_close(msh);
}

GList *
search_by_address(GList *result_list, struct mapset *ms, char *addr, int partial, struct jni_object *jni, int search_country_flags, char *search_country_string)
{
        char *str = search_fix_spaces(addr);
        GList *tmp, *phrases = search_split_phrases(str);
        GList *phrases_first;
        GList *ret = NULL;
        struct search_list *sl;
        struct attr attr;
        attr.type = attr_country_all;
        tmp = phrases;
        phrases_first = phrases;
        sl = search_list_new(ms);

        dbg(0, "-- START --\n");

        // normal search stuff -------- START ----------
        if (search_country_flags == 1)
        {
                dbg(0, "-- country default start --\n");
                //while (phrases)
                //{
                // dbg(0,"s=%s\n",phrases->data);
                // set default country
                search_list_search(sl, country_default(), 0);
                ret = search_address__country(ret, sl, phrases, NULL, partial, jni);
                // phrases=g_list_next(phrases);
                //}
                dbg(0, "-- country default end --\n");
        }
        else if (search_country_flags == 2)
        {
                dbg(0, "-- country sel:%s start --\n", search_country_string);
                // set a country
                struct attr country;
                country.type = attr_country_iso2;
                country.u.str = search_country_string;
                //while (phrases)
                //{
                // dbg(0,"s=%s\n",phrases->data);
                search_list_search(sl, &country, 0);
                // set a country
                ret = search_address__country(ret, sl, phrases, NULL, partial, jni);
                //phrases=g_list_next(phrases);
                //}
                dbg(0, "-- country sel:%s end --\n", search_country_string);
        }
        else // flags==3
        {
                dbg(0, "-- country all start --\n");
                // search all countries!! could take a really long time!!
                struct attr country;
                int j2 = sizeof(all_country_list) / sizeof(all_country_list[0]);
                int j1;
                for (j1 = 0; j1 < j2; j1++)
                {
                        if (all_country_list[j1].iso2 != NULL)
                        {
                                phrases = phrases_first;
                                //while (phrases)
                                //{
                                // dbg(0,"s country=%s\n",all_country_list[j1].iso2);
                                // dbg(0,"s=%s\n",phrases->data);
                                country.type = attr_country_iso2;
                                country.u.str = all_country_list[j1].iso2;
                                search_list_search(sl, &country, 0);
                                ret = search_address__country(ret, sl, phrases, NULL, partial, jni);
                                //phrases=g_list_next(phrases);
                                //}

                                if (offline_search_break_searching == 1)
                                {
                                        break;
                                }
                        }
                }
                dbg(0, "-- country all end --\n");
        }
        // normal search stuff --------  END  ----------

        if (phrases_first)
        {
                g_list_free(phrases_first);
        }

        dbg(0, "--  END  --\n");

        g_free(str);
        return ret;
}
