8.28-bob: Geolokatsiya va xaritalar

  KOORDINATA — Yerdagi nuqta (2 son):
  - Latitude (kenglik): -90 dan +90 gacha (shimol/janub) — Toshkent ~41.31
  - Longitude (uzunlik): -180 dan +180 gacha (sharq/g'arb) — Toshkent ~69.24

   Tartib chalkashligi: GeoJSON [lng, lat]; ko'p API [lat, lng]
   diqqat: qaysi tartib (eng keng xato)

  Saqlash: ikki ustun (lat, lng) yoki geo turi (POINT — PostGIS/Mongo)

  KOORDINATA TIZIMI (SRID):
  - WGS84 (SRID 4326) — GPS/GeoJSON standarti (gradus: lat/lng)
     deyarli hamma joyda (GPS, telefon, xarita API) shu
  - Web Mercator (SRID 3857) — xarita rasmini chizishda (metr, tekislik)
   DB da har doim aniq SRID: geography(POINT, 4326)

// Ikki koordinata orasidagi masofa (Yer sharsimon — Haversine formulasi)
function masofa(lat1: number, lng1: number, lat2: number, lng2: number): number {
  const R = 6371;                                     // Yer radiusi (km)
  const dLat = ((lat2 - lat1) * Math.PI) / 180;
  const dLng = ((lng2 - lng1) * Math.PI) / 180;
  const a = Math.sin(dLat / 2) ** 2 +
    Math.cos((lat1 * Math.PI) / 180) * Math.cos((lat2 * Math.PI) / 180) * Math.sin(dLng / 2) ** 2;
  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));   // km
}

  MUAMMO: "5 km radiusdagi do'konlar" — har do'konni Haversine bilan
  tekshirish  100000 do'kon  100000 hisoblash (SEKIN!)

  YECHIM — GEO-INDEKS (DB darajasida — tez):
  - PostgreSQL: PostGIS (geography turi + GIST indeks)
  - MongoDB: 2dsphere indeks 8.13-bob + $near/$geoWithin
   DB indeks bilan eng yaqinlarni TEZ topadi (millisekund)

  "Eng yaqin 10 do'kon" / "5 km radiusdagi" — DB so'rovi (qo'lda emas)

// MongoDB — 2dsphere indeks + $near (8.13)
@Schema()
export class Filial {
  @Prop({ type: { type: String, enum: ["Point"], default: "Point" }, coordinates: [Number] })
  joylashuv: { type: string; coordinates: [number, number] };   // [lng, lat] — GeoJSON (2.1)
}
FilialSchema.index({ joylashuv: "2dsphere" });        // geo-indeks (tezlik — 8.13)

// Eng yaqin filiallar (DB so'rovi — tez)
async engYaqin(lat: number, lng: number, radiusKm: number) {
  return this.model.find({
    joylashuv: {
      $near: {
        $geometry: { type: "Point", coordinates: [lng, lat] },   // [lng, lat]!
        $maxDistance: radiusKm * 1000,                // metr
      },
    },
  }).limit(10);
}

-- 1) Kengaytmani yoqish (bir marta, DB'da)
CREATE EXTENSION IF NOT EXISTS postgis;

-- 2) Geo-ustun qo'shish (SRID 4326 = WGS84 — 2.1)
ALTER TABLE filiallar ADD COLUMN joylashuv geography(POINT, 4326);

-- 3) Koordinata yozish ( ST_MakePoint(lng, lat) — uzunlik BIRINCHI)
UPDATE filiallar
SET joylashuv = ST_SetSRID(ST_MakePoint(69.24, 41.31), 4326)::geography;

-- 4) GiST spatial indeks (tezlik — buni unutmang!)
CREATE INDEX idx_filiallar_geo ON filiallar USING GIST (joylashuv);

  geometry  vs  geography — ikki tur, farqni bilish MUHIM:

  geometry (tekislik):
  - koordinatalarni yassi (Dekart) tekislik deb hisoblaydi
  - hisoblash TEZ, lekin katta masofada Yer egriligini hisobga olmaydi
  - masofa — koordinata birligida (gradus — km emas!)
  - kichik hudud / Web Mercator xarita uchun

  geography (sfera):
  - Yerni shar deb hisoblaydi (WGS84)
  - ST_Distance  METR qaytaradi (real masofa, egrilik bilan)
  - biroz sekinroq, lekin masofa/radius uchun TO'G'RI
  - yetkazib berish, "5 km radius" uchun  geography TANLANG

-- <-> KNN: radius belgilamasdan eng yaqin 10 ta (indeks bilan juda tez)
SELECT nom,
       joylashuv <-> ST_SetSRID(ST_MakePoint(69.24, 41.31), 4326)::geography AS masofa
FROM filiallar
ORDER BY joylashuv <-> ST_SetSRID(ST_MakePoint(69.24, 41.31), 4326)::geography
LIMIT 10;
--  ORDER BY ... <-> ... LIMIT n  GiST indeks KNN rejimida ishlaydi (index-only, tez)

-- Sof SQL Haversine (PostGIS'siz — 6371 km Yer radiusi)
SELECT nom,
       6371 * 2 * asin(sqrt(
         power(sin(radians($2 - lat) / 2), 2) +
         cos(radians(lat)) * cos(radians($2)) *
         power(sin(radians($1 - lng) / 2), 2)
       )) AS masofa_km              -- $1=lng, $2=lat
FROM filiallar
WHERE lat BETWEEN $2 - 0.1 AND $2 + 0.1     -- oldindan bounding box (indeks — tez)
  AND lng BETWEEN $1 - 0.1 AND $1 + 0.1
ORDER BY masofa_km ASC LIMIT 10;

// TypeORM: geo-ustun + GiST indeks (entity)
@Entity("filiallar")
@Index("idx_filial_geo", { synchronize: false })       // GiST raw migration'da
export class FilialEntity {
  @PrimaryGeneratedColumn() id: number;
  @Column() nom: string;

  @Column({
    type: "geography",
    spatialFeatureType: "Point",
    srid: 4326,                                          // WGS84 (2.1)
    nullable: true,
  })
  joylashuv: string;                                     // WKT/GeoJSON sifatida
}
// So'rov — raw (parametrli — 8.4)
async engYaqin(lat: number, lng: number, limit = 10) {
  return this.repo.query(
    `SELECT id, nom,
            joylashuv <-> ST_SetSRID(ST_MakePoint($1, $2), 4326)::geography AS masofa
     FROM filiallar
     ORDER BY joylashuv <-> ST_SetSRID(ST_MakePoint($1, $2), 4326)::geography
     LIMIT $3`,
    [lng, lat, limit],                                   // $1=lng, $2=lat
  );
}

  GeoJSON — geo-ma'lumot uchun standart JSON format (API javobi):

  Point (nuqta):
  { "type": "Point", "coordinates": [69.24, 41.31] }   // [lng, lat]!

  Polygon (zona — 2.6):
  { "type": "Polygon", "coordinates": [[[lng,lat],[lng,lat],...]] }
   birinchi va oxirgi nuqta bir xil (yopiq halqa)

  Feature (nuqta + xossalar):
  { "type": "Feature",
    "geometry": { "type":"Point", "coordinates":[69.24,41.31] },
    "properties": { "nom": "Filial 1", "narx": 15000 } }

// Bounding box: xarita ko'rinishidagi filiallar (arzon filtr)
async xaritaViewport(minLat: number, minLng: number, maxLat: number, maxLng: number) {
  // MongoDB $geoWithin + $box (to'rtburchak — [pastki-chap, yuqori-o'ng])
  return this.model.find({
    joylashuv: {
      $geoWithin: { $box: [[minLng, minLat], [maxLng, maxLat]] },   // [lng, lat]!
    },
  });
  // PostGIS muqobili: WHERE joylashuv && ST_MakeEnvelope(minLng,minLat,maxLng,maxLat,4326)
}

  GEOCODING — manzil  koordinata:
  "Toshkent, Amir Temur ko'chasi 1"  { lat: 41.31, lng: 69.27 }

  REVERSE GEOCODING — koordinata  manzil:
  { lat: 41.31, lng: 69.27 }  "Toshkent, Amir Temur ko'chasi"

  Xizmatlar (O'zbekiston):
  - Yandex Geocoder API (O'zbekistonda eng aniq)
  - Google Geocoding API
  - OpenStreetMap Nominatim (bepul, kamroq aniq)

   Foydalanuvchi manzil yozadi  geocoding  koordinata (saqlash/masofa)

// Nominatim (OSM) — bepul geocoding.  User-Agent SHART, soniyasiga 1 so'rov
async geocodeNominatim(manzil: string): Promise<{ lat: number; lng: number } | null> {
  const { data } = await firstValueFrom(this.http.get("https://nominatim.openstreetmap.org/search", {
    params: { q: manzil, format: "jsonv2", limit: 1 },
    headers: { "User-Agent": "MeningIlovam/1.0 (aloqa@example.uz)" },   // majburiy (aks holda bloklanadi)
  }));
  if (!data?.length) return null;
  return { lat: Number(data[0].lat), lng: Number(data[0].lon) };        // Nominatim: string qaytaradi
}

// Reverse (koordinata  manzil)
async reverseNominatim(lat: number, lng: number): Promise<string | null> {
  const { data } = await firstValueFrom(this.http.get("https://nominatim.openstreetmap.org/reverse", {
    params: { lat, lon: lng, format: "jsonv2" },
    headers: { "User-Agent": "MeningIlovam/1.0 (aloqa@example.uz)" },
  }));
  return data?.display_name ?? null;                                    // to'liq manzil matni
}

// OSRM — yo'l bo'yicha real masofa/vaqt (bepul Distance Matrix muqobili — 2.7)
//  OSRM URL tartibi: {lng},{lat} — uzunlik BIRINCHI (2.1)
async realMasofaOsrm(from: { lat: number; lng: number }, to: { lat: number; lng: number }) {
  const koord = `${from.lng},${from.lat};${to.lng},${to.lat}`;
  const { data } = await firstValueFrom(
    this.http.get(`https://router.project-osrm.org/route/v1/driving/${koord}`, {
      params: { overview: "false" },                                   // geometriya kerak emas — faqat masofa/vaqt
    }),
  );
  const r = data?.routes?.[0];
  if (!r) return null;
  return { masofa: r.distance, vaqt: r.duration };                     // metr, soniya (yo'l bo'yicha)
}

// Zona — poligon (xaritadagi maydon). Nuqta zona ichidami?
async zonadaMi(lat: number, lng: number): Promise<DeliveryZone | null> {
  // MongoDB $geoIntersects — nuqta poligon ichidami
  return this.zoneModel.findOne({
    hudud: {
      $geoIntersects: {
        $geometry: { type: "Point", coordinates: [lng, lat] },
      },
    },
  });
}
// Zona hudud: GeoJSON Polygon (koordinatalar ro'yxati — chegara)
//  "Bu manzilga yetkazamizmi?" + qaysi zona (narx farqi)

  XARITA XIZMATLARI:
  ┌──────────────┬────────────────────────────────────────────┐
  │ Yandex Maps  │ O'zb  istonda ENG ANIQ (manzil, marshrut)   │
  │              │ Geocoder, Routing, Distance Matrix          │
  ├──────────────┼────────────────────────────────────────────┤
  │ Google Maps  │ Global, kuchli (ba'zi joyda O'zb kamroq)    │
  ├──────────────┼────────────────────────────────────────────┤
  │ OpenStreetMap│ Bepul, ochiq (Nominatim geocode, OSRM rout)│
  │ + Leaflet    │ Frontend xarita (bepul)                    │
  └──────────────┴────────────────────────────────────────────┘
  Backend: geocoding, distance matrix (real masofa — yo'l bo'yicha)
  Frontend (11): xarita ko'rsatish (Yandex/Leaflet)

// Provayder proxy: kalit backend'da, kesh + rate limit (frontend to'g'ridan-to'g'ri provayderga bormaydi)
@Controller("geo")
@UseGuards(ThrottlerGuard)                                // 8.6 — rate limit
export class GeoController {
  constructor(private geocoding: GeocodingService) {}

  @Get("geocode")
  @Throttle({ default: { limit: 20, ttl: 60_000 } })     // 1 foydalanuvchi: 20 so'rov / daqiqa
  async geocode(@Query("q") manzil: string) {
    if (!manzil || manzil.length < 3) {
      throw new BadRequestException("Manzil juda qisqa");  // arzon so'rovlarni oldini olish
    }
    const natija = await this.geocoding.geocode(manzil);   // ichida kesh (Misol 5) — kvota tejash
    if (!natija) throw new NotFoundException("Manzil topilmadi");
    return natija;                                         // API kalit hech qachon frontend'ga chiqmaydi
  }
}

// Kuryer joylashuvini real-time kuzatish (taksi/yetkazib berish)
@SubscribeMessage("kuryer_joylashuv")                 // WebSocket (8.18)
async kuryerJoylashuv(@MessageBody() data: { kuryerId: string; lat: number; lng: number }) {
  // Joylashuvni saqlash (Redis — tez, vaqtinchalik — 8.15)
  await this.redis.geoadd("kuryerlar", data.lng, data.lat, data.kuryerId);
  // Buyurtma mijoziga uzatish (kuryer xaritada harakatlanadi)
  const buyurtma = await this.findActiveOrder(data.kuryerId);
  if (buyurtma) {
    this.server.to(`order_${buyurtma.id}`).emit("kuryer_harakati", { lat: data.lat, lng: data.lng });
  }
}
// Redis GEO — geo-qidiruv tez (GEOSEARCH — eng yaqin kuryer)

   Joylashuv MAXFIY (foydalanuvchi uyi — ruxsat bilan, EXIF tozalash — 8.24)
   Faqat kerakli aniqlik (taksi — aniq; statistika — shahar darajasi)
   Koordinata validatsiyasi (lat -90..90, lng -180..180 — 8.5)
   Geocoding kesh (kvota/narx — 8.15, 2.5)
   Tartib diqqat ([lng,lat] vs [lat,lng] — 2.1)
   Geo-indeks (tezlik — 2.4); Redis GEO (real-time — 2.8)
   Joylashuv tarixini saqlash muddati (maxfiylik — kerakli vaqt)

   Geo-indeks (eng yaqin — tez — DB so'rovi — 2.3, 2.4)
   GeoJSON tartib ([lng, lat] — diqqat — 2.1)
   Haversine (oddiy masofa); Distance Matrix (real yo'l — 2.2, 2.7)
   Geocoding kesh (kvota — 8.15, 2.5)
   Zona — poligon ($geoIntersects — 2.6)
   Real-time  Redis GEO + WebSocket 2.8-bob
   Yandex (O'zbekiston aniqlik — 2.7)
   Joylashuv maxfiyligi (ruxsat, aniqlik, muddat — 14, 2.9)
   Koordinata validatsiya (8.5)

// Koordinata 2.1-bob: GeoJSON Point { type: "Point", coordinates: [lng, lat] }
// Masofa 2.2-bob: Haversine (R=6371 km)
// Geo-indeks 2.4-bob: Mongo 2dsphere; PostGIS GIST
// Eng yaqin 2.4-bob: $near + $maxDistance / ST_DWithin
// Zona 2.6-bob: $geoIntersects / ST_Contains (poligon)
// Real-time 2.8-bob: Redis GEOADD/GEOSEARCH + WebSocket

@Schema({ timestamps: true })
export class Filial {
  @Prop({ required: true }) nom: string;
  @Prop({ required: true }) manzil: string;

  @Prop({
    type: { type: String, enum: ["Point"], default: "Point" },
    coordinates: { type: [Number], required: true },   // [lng, lat] — GeoJSON (2.1)
  })
  joylashuv: { type: string; coordinates: [number, number] };
}
export const FilialSchema = SchemaFactory.createForClass(Filial);
FilialSchema.index({ joylashuv: "2dsphere" });        // GEO-INDEKS (2.4)

@Injectable()
export class FilialService {
  constructor(@InjectModel(Filial.name) private model: Model<Filial>) {}

  async engYaqin(lat: number, lng: number, radiusKm = 5, limit = 10) {
    return this.model.find({
      joylashuv: {
        $near: {                                       // eng yaqin (saralangan)
          $geometry: { type: "Point", coordinates: [lng, lat] },   // [lng, lat]!
          $maxDistance: radiusKm * 1000,              // metr
        },
      },
    }).limit(limit).exec();
    //  eng yaqindan tartibda, radius ichida (indeks bilan tez)
  }

  // Masofa bilan (aggregation — $geoNear)
  async engYaqinMasofaBilan(lat: number, lng: number) {
    return this.model.aggregate([
      {
        $geoNear: {
          near: { type: "Point", coordinates: [lng, lat] },
          distanceField: "masofa",                     // har filialga masofa (metr)
          maxDistance: 10000, spherical: true,
        },
      },
      { $limit: 10 },
    ]);
    //  [{ nom, masofa: 1234 }, ...] (masofa bilan)
  }
}

class NearbyDto {
  @Type(() => Number) @IsLatitude() lat: number;       // -90..90 (validatsiya — 8.5)
  @Type(() => Number) @IsLongitude() lng: number;      // -180..180
  @Type(() => Number) @IsOptional() @Min(0.1) @Max(50) radius?: number = 5;
}

@Controller("filiallar")
export class FilialController {
  @Get("nearby")
  engYaqin(@Query() dto: NearbyDto) {                  // ?lat=41.31&lng=69.24&radius=5
    return this.service.engYaqin(dto.lat, dto.lng, dto.radius);
  }
}

// PostGIS — geography turi + GIST indeks
// migration: ALTER TABLE filiallar ADD COLUMN joylashuv geography(POINT);
//            CREATE INDEX ON filiallar USING GIST(joylashuv);

@Injectable()
export class FilialPgService {
  // Eng yaqin (PostGIS — ST_DWithin + ST_Distance)
  async engYaqin(lat: number, lng: number, radiusKm: number) {
    return this.dataSource.query(`
      SELECT *, ST_Distance(joylashuv, ST_MakePoint($1, $2)::geography) AS masofa
      FROM filiallar
      WHERE ST_DWithin(joylashuv, ST_MakePoint($1, $2)::geography, $3)   -- radius (metr)
      ORDER BY masofa ASC LIMIT 10
    `, [lng, lat, radiusKm * 1000]);                  // $1=lng, $2=lat (8.4 parametrli)
  }
}

@Injectable()
export class GeocodingService {
  constructor(
    private http: HttpService,                         // (2.18-JS Axios)
    private config: ConfigService,
    @Inject(CACHE_MANAGER) private cache: Cache,       // kesh (8.15)
  ) {}

  // Manzil  koordinata (kesh bilan — kvota — 2.5)
  async geocode(manzil: string): Promise<{ lat: number; lng: number } | null> {
    const keshKalit = `geocode:${manzil}`;
    const keshda = await this.cache.get(keshKalit);
    if (keshda) return keshda as any;                  // keshdan (kvota tejash)

    const { data } = await firstValueFrom(this.http.get("https://geocode-maps.yandex.ru/1.x", {
      params: { apikey: this.config.get("YANDEX_API_KEY"), geocode: manzil, format: "json" },
    }));
    const pos = data.response?.GeoObjectCollection?.featureMember?.[0]?.GeoObject?.Point?.pos;
    if (!pos) return null;
    const [lng, lat] = pos.split(" ").map(Number);     // Yandex: "lng lat"
    const natija = { lat, lng };
    await this.cache.set(keshKalit, natija, 86400000); // 1 kun kesh
    return natija;
  }
}

@Schema()
export class DeliveryZone {
  @Prop() nom: string;
  @Prop() narx: number;                                // shu zona yetkazish narxi
  @Prop({
    type: { type: String, enum: ["Polygon"] },
    coordinates: { type: [[[Number]]] },               // poligon (GeoJSON)
  })
  hudud: { type: string; coordinates: number[][][] };
}
DeliveryZoneSchema.index({ hudud: "2dsphere" });

// Manzil zonadami + narx
async yetkazishNarxi(lat: number, lng: number): Promise<number> {
  const zona = await this.zoneModel.findOne({
    hudud: { $geoIntersects: { $geometry: { type: "Point", coordinates: [lng, lat] } } },
  });
  if (!zona) throw new BadRequestException("Bu manzilga yetkazib bermaymiz");
  return zona.narx;
}

// Yo'l bo'yicha real masofa va vaqt (Haversine to'g'ri chiziq emas — traffic)
async realMasofa(from: { lat: number; lng: number }, to: { lat: number; lng: number }) {
  const { data } = await firstValueFrom(this.http.get("https://api.routing.yandex.net/v2/route", {
    params: {
      apikey: this.config.get("YANDEX_ROUTING_KEY"),
      waypoints: `${from.lat},${from.lng}|${to.lat},${to.lng}`,
    },
  }));
  return {
    masofa: data.distance,                             // real yo'l masofasi (metr)
    vaqt: data.duration,                               // traffic bilan vaqt (soniya)
  };
  //  yetkazish vaqti taxmini, narx (real masofa — Haversine'dan aniqroq)
}

@WebSocketGateway({ namespace: "tracking" })
export class TrackingGateway {
  @WebSocketServer() server: Server;
  constructor(@InjectRedis() private redis: Redis) {}

  // Kuryer joylashuvini yangilash
  @SubscribeMessage("kuryer_update")
  async kuryerUpdate(@MessageBody() d: { kuryerId: string; lat: number; lng: number; orderId: string }) {
    await this.redis.geoadd("kuryerlar", d.lng, d.lat, d.kuryerId);   // Redis GEO (2.8)
    // Mijozga uzatish (kuryer xaritada harakatlanadi)
    this.server.to(`order_${d.orderId}`).emit("kuryer_harakati", { lat: d.lat, lng: d.lng });
  }

  // Eng yaqin kuryer (taksi — buyurtma uchun)
  async engYaqinKuryer(lat: number, lng: number) {
    return this.redis.geosearch("kuryerlar", "FROMLONLAT", lng, lat,
      "BYRADIUS", 5, "km", "ASC", "COUNT", 5);        // 5 km, eng yaqin 5
  }
}

@Injectable()
export class DeliveryService {
  // Buyurtma berishda — manzil tekshirish + narx
  async buyurtmaTekshir(lat: number, lng: number) {
    const narx = await this.yetkazishNarxi(lat, lng);          // zona (Misol 6)
    const filial = await this.filialService.engYaqin(lat, lng, 10, 1);   // eng yaqin filial (Misol 2)
    const masofa = await this.realMasofa(                       // real masofa (Misol 7)
      { lat: filial[0].joylashuv.coordinates[1], lng: filial[0].joylashuv.coordinates[0] },
      { lat, lng },
    );
    return {
      yetkaziladi: true, narx, filial: filial[0].nom,
      taxminiyVaqt: Math.ceil(masofa.vaqt / 60),               // daqiqa
    };
  }
}

  src/geo/
  ├── geocoding.service.ts       (manzilkoordinata — Misol 5)
  ├── filial.service.ts          (eng yaqin — Misol 2)
  ├── delivery.service.ts        (zona, narx — Misol 6, 9)
  ├── tracking.gateway.ts        (real-time — Misol 8)
  ├── routing.service.ts         (distance matrix — Misol 7)
  └── geo.module.ts

  Oqim (yetkazib berish):
  - Manzil  geocoding  koordinata (Misol 5)
  - Zona tekshir + narx (Misol 6); eng yaqin filial (Misol 2)
  - Real masofa/vaqt (Misol 7)
  - Kuryer real-time kuzatuv (Redis GEO + WebSocket — Misol 8)

   Geo-indeks (tez); GeoJSON [lng,lat]; Yandex (O'zbekiston); maxfiylik (14)

 har nuqtani Haversine (sekin — 2.3)
 geo-indeks ($near/ST_DWithin)

 tartib aralash (nuqta okeanda — 2.1)
 GeoJSON [lng, lat] (diqqat)

 bir manzil qayta-qayta (kvota/narx — 2.5)
 kesh (8.15)

 Haversine (yo'l emas — 2.7)
 Distance Matrix (real yo'l/traffic)

 maxfiy joylashuv suiiste'mol (14, 2.9)
 ruxsat + kerakli aniqlik + muddat