import { languageInstance } from "@shared";
import { makeAutoObservable } from "mobx";

interface ApiRoute {
  id: number;
  route_number: string;
  path: [number, number][];
}

interface ApiStation {
  id: number;
  name: string;
  latitude: number;
  longitude: number;
}

interface ApiSight {
  id: number;
  name: string;
  description: string;
  latitude: number;
  longitude: number;
}

class MapStore {
  constructor() {
    makeAutoObservable(this);
  }

  routes: ApiRoute[] = [];
  stations: ApiStation[] = [];
  sights: ApiSight[] = [];

  getRoutes = async () => {
    const routes = await languageInstance("ru").get("/route");

    const mappedRoutes = routes.data.map((route: any) => ({
      id: route.id,
      route_number: route.route_number,
      path: route.path,
    }));

    this.routes = mappedRoutes;
  };

  getStations = async () => {
    const stations = await languageInstance("ru").get("/station");
    const mappedStations = stations.data.map((station: any) => ({
      id: station.id,
      name: station.name,
      latitude: station.latitude,
      longitude: station.longitude,
    }));

    this.stations = mappedStations;
  };

  getSights = async () => {
    const sights = await languageInstance("ru").get("/sight");
    const mappedSights = sights.data.map((sight: any) => ({
      id: sight.id,
      name: sight.name,
      description: sight.description,
      latitude: sight.latitude,
      longitude: sight.longitude,
    }));

    this.sights = mappedSights;
  };

  deleteRecourse = async (recourse: string, id: number) => {
    await languageInstance("ru").delete(`/${recourse}/${id}`);
    if (recourse === "route") {
      this.routes = this.routes.filter((route) => route.id !== id);
    } else if (recourse === "station") {
      this.stations = this.stations.filter((station) => station.id !== id);
    } else if (recourse === "sight") {
      this.sights = this.sights.filter((sight) => sight.id !== id);
    }
  };

  handleSave = async (json: string) => {
    const sights: any[] = [];
    const routes: any[] = [];
    const stations: any[] = [];

    const parsedJSON = JSON.parse(json);

    console.log(parsedJSON);
    parsedJSON.features.forEach((feature: any) => {
      const { geometry, properties, id } = feature;
      const idCanBeSplited = id.split("-");

      if (!(idCanBeSplited.length > 1)) {
        if (properties.featureType === "station") {
          stations.push({
            name: properties.name || "",
            latitude: geometry.coordinates[1],
            longitude: geometry.coordinates[0],
          });
        } else if (properties.featureType === "route") {
          routes.push({
            route_number: properties.name || "",
            path: geometry.coordinates,
          });
        } else if (properties.featureType === "sight") {
          sights.push({
            name: properties.name || "",
            description: properties.description || "",
            latitude: geometry.coordinates[1],
            longitude: geometry.coordinates[0],
          });
        }
      }
    });

    for (const station of stations) {
      await languageInstance("ru").post("/station", station);
    }
    for (const route of routes) {
      await languageInstance("ru").post("/route", route);
    }
    for (const sight of sights) {
      await languageInstance("ru").post("/sight", sight);
    }
  };
}

export default new MapStore();