import { authInstance } from "@shared";

import { makeAutoObservable, runInAction } from "mobx";
// Импорт функции сброса кешей карты
// import { clearMapCaches } from "../../pages/MapPage";
import {
  articlesStore,
  cityStore,
  countryStore,
  carrierStore,
  stationsStore,
  sightsStore,
  routeStore,
  vehicleStore,
  userStore,
  mediaStore,
  createSightStore,
  editSightStore,
  devicesStore,
  authStore,
} from "@shared";

type Snapshot = {
  ID: string;
  Name: string;
  ParentID: string;
  CreationTime: string;
};

class SnapshotStore {
  snapshots: Snapshot[] = [];
  snapshot: Snapshot | null = null;

  constructor() {
    makeAutoObservable(this);
  }

  // Функция для сброса всех кешей в приложении
  private clearAllCaches = () => {
    // Сброс кешей статей
    articlesStore.articleList = {
      ru: { data: [], loaded: false },
      en: { data: [], loaded: false },
      zh: { data: [], loaded: false },
    };
    articlesStore.articlePreview = {};
    articlesStore.articleData = null;
    articlesStore.articleMedia = null;

    // Сброс кешей городов
    cityStore.cities = {
      ru: { data: [], loaded: false },
      en: { data: [], loaded: false },
      zh: { data: [], loaded: false },
    };
    cityStore.ruCities = { data: [], loaded: false };
    cityStore.city = {};

    // Сброс кешей стран
    countryStore.countries = {
      ru: { data: [], loaded: false },
      en: { data: [], loaded: false },
      zh: { data: [], loaded: false },
    };

    // Сброс кешей перевозчиков
    carrierStore.carriers = {
      ru: { data: [], loaded: false },
      en: { data: [], loaded: false },
      zh: { data: [], loaded: false },
    };

    // Сброс кешей станций
    stationsStore.stationLists = {
      ru: { data: [], loaded: false },
      en: { data: [], loaded: false },
      zh: { data: [], loaded: false },
    };
    stationsStore.stationPreview = {};

    // Сброс кешей достопримечательностей
    sightsStore.sights = [];
    sightsStore.sight = null;

    // Сброс кешей маршрутов
    routeStore.routes = { data: [], loaded: false };

    // Сброс кешей транспорта
    vehicleStore.vehicles = { data: [], loaded: false };

    // Сброс кешей пользователей
    userStore.users = { data: [], loaded: false };

    // Сброс кешей медиа
    mediaStore.media = [];
    mediaStore.oneMedia = null;

    // Сброс кешей создания и редактирования достопримечательностей
    createSightStore.sight = JSON.parse(
      JSON.stringify({
        city_id: 0,
        city: "",
        latitude: 0,
        longitude: 0,
        thumbnail: null,
        watermark_lu: null,
        watermark_rd: null,
        left_article: 0,
        preview_media: null,
        video_preview: null,
        ru: {
          name: "",
          address: "",
          left: { heading: "", body: "", media: [] },
          right: [],
        },
        en: {
          name: "",
          address: "",
          left: { heading: "", body: "", media: [] },
          right: [],
        },
        zh: {
          name: "",
          address: "",
          left: { heading: "", body: "", media: [] },
          right: [],
        },
      })
    );
    createSightStore.uploadMediaOpen = false;
    createSightStore.fileToUpload = null;
    createSightStore.needLeaveAgree = false;

    editSightStore.sight = {
      common: {
        id: 0,
        city_id: 0,
        city: "",
        latitude: 0,
        longitude: 0,
        thumbnail: null,
        watermark_lu: null,
        watermark_rd: null,
        left_article: 0,
        preview_media: null,
        video_preview: null,
      },
      ru: {
        id: 0,
        name: "",
        address: "",
        left: { heading: "", body: "", media: [] },
        right: [],
      },
      en: {
        id: 0,
        name: "",
        address: "",
        left: { heading: "", body: "", media: [] },
        right: [],
      },
      zh: {
        id: 0,
        name: "",
        address: "",
        left: { heading: "", body: "", media: [] },
        right: [],
      },
    };
    editSightStore.hasLoadedCommon = false;
    editSightStore.uploadMediaOpen = false;
    editSightStore.fileToUpload = null;
    editSightStore.needLeaveAgree = false;

    // Сброс кешей устройств
    devicesStore.devices = [];
    devicesStore.uuid = null;
    devicesStore.sendSnapshotModalOpen = false;

    // Сброс кешей авторизации (кроме токена)
    authStore.payload = null;
    authStore.error = null;
    authStore.isLoading = false;

    // Сброс кешей карты (если они загружены)
    try {
      // Сбрасываем кеши mapStore если он доступен
      if (typeof window !== "undefined" && (window as any).mapStore) {
        (window as any).mapStore.routes = [];
        (window as any).mapStore.stations = [];
        (window as any).mapStore.sights = [];
      }

      // Сбрасываем кеши MapService если он доступен
      if (typeof window !== "undefined" && (window as any).mapServiceInstance) {
        (window as any).mapServiceInstance.clearCaches();
      }
    } catch (error) {
      console.warn("Не удалось сбросить кеши карты:", error);
    }

    // Сброс localStorage кешей (кроме токена авторизации)
    const token = localStorage.getItem("token");
    const rememberedEmail = localStorage.getItem("rememberedEmail");
    const rememberedPassword = localStorage.getItem("rememberedPassword");

    localStorage.clear();
    sessionStorage.clear();

    // Восстанавливаем важные данные
    if (token) localStorage.setItem("token", token);
    if (rememberedEmail)
      localStorage.setItem("rememberedEmail", rememberedEmail);
    if (rememberedPassword)
      localStorage.setItem("rememberedPassword", rememberedPassword);

    // Сброс кешей карты (если они есть)
    const mapPositionKey = "mapPosition";
    const activeSectionKey = "mapActiveSection";
    if (localStorage.getItem(mapPositionKey)) {
      localStorage.removeItem(mapPositionKey);
    }
    if (localStorage.getItem(activeSectionKey)) {
      localStorage.removeItem(activeSectionKey);
    }

    // Попытка очистить кеш браузера (если поддерживается)
    if ("caches" in window) {
      try {
        caches.keys().then((cacheNames) => {
          return Promise.all(
            cacheNames.map((cacheName) => {
              return caches.delete(cacheName);
            })
          );
        });
      } catch (error) {
        console.warn("Кеш браузера не поддерживается:", error);
      }
    }

    // Попытка очистить IndexedDB (если поддерживается)
    if ("indexedDB" in window) {
      try {
        indexedDB.databases().then((databases) => {
          return Promise.all(
            databases.map((db) => {
              if (db.name) {
                return indexedDB.deleteDatabase(db.name);
              }
              return Promise.resolve();
            })
          );
        });
      } catch (error) {
        console.warn("IndexedDB не поддерживается:", error);
      }
    }
  };

  getSnapshots = async () => {
    const response = await authInstance.get(`/snapshots`);

    runInAction(() => {
      this.snapshots = response.data;
    });
  };

  deleteSnapshot = async (id: string) => {
    await authInstance.delete(`/snapshots/${id}`);

    runInAction(() => {
      this.snapshots = this.snapshots.filter((snapshot) => snapshot.ID !== id);
    });
  };

  getSnapshot = async (id: string) => {
    const response = await authInstance.get(`/snapshots/${id}`);

    runInAction(() => {
      this.snapshot = response.data;
    });
  };

  restoreSnapshot = async (id: string) => {
    // Сначала сбрасываем все кеши
    this.clearAllCaches();

    // Затем восстанавливаем снапшот
    await authInstance.post(`/snapshots/${id}/restore`);
  };

  createSnapshot = async (name: string) => {
    await authInstance.post(`/snapshots`, { name });
  };
}

export const snapshotStore = new SnapshotStore();