/**
 * Tenant Store
 *
 * 管理租户上下文和租户相关状态（平台无关）
 */
import { defineStore } from 'pinia';
import { ref, computed, type Ref } from 'vue';
import type { Tenant } from '../api/modules/tenant';
import type { IStorageAdapter } from '../adapters/storage/interface';
import type { IRequestAdapter } from '../adapters/request/interface';
import { StorageKey } from '../adapters/storage/interface';
import { logger } from '../utils/logger';

// 全局适配器实例
let storageAdapter: IStorageAdapter;
let requestAdapter: IRequestAdapter;

/**
 * 设置存储适配器
 */
export function setTenantStorageAdapter(adapter: IStorageAdapter) {
  storageAdapter = adapter;
}

/**
 * 设置请求适配器
 */
export function setTenantRequestAdapter(adapter: IRequestAdapter) {
  requestAdapter = adapter;
}

export const useTenantStore = defineStore('tenant', () => {
  // State
  const currentTenant: Ref<Tenant | null> = ref(null);
  const tenants: Ref<Tenant[]> = ref([]);
  const loading = ref(false);

  // Computed
  const tenantId = computed(() => currentTenant.value?.id);
  const tenantName = computed(() => currentTenant.value?.name);
  const tenantCode = computed(() => currentTenant.value?.code);

  /**
   * 从用户数据设置当前租户
   */
  const setTenantFromUser = (user: any) => {
    if (user && user.tenant_id) {
      if (user.tenant) {
        currentTenant.value = user.tenant;
      } else {
        fetchTenant(user.tenant_id);
      }
    }
  };

  /**
   * 获取租户详情
   */
  const fetchTenant = async (id: number) => {
    try {
      loading.value = true;
      const response = await requestAdapter.get<Tenant>(`/api/v1/tenants/${id}`);
      currentTenant.value = response.data;
    } catch (error) {
      logger.error('TenantStore', 'Failed to fetch tenant', error, { tenantId: id });
    } finally {
      loading.value = false;
    }
  };

  /**
   * 获取所有租户（仅平台管理员）
   */
  const fetchTenants = async () => {
    try {
      loading.value = true;
      const response = await requestAdapter.get<Tenant[]>('/api/v1/tenants');
      tenants.value = response.data;
    } catch (error) {
      logger.error('TenantStore', 'Failed to fetch tenants', error);
    } finally {
      loading.value = false;
    }
  };

  /**
   * 切换租户（仅平台管理员）
   */
  const switchTenant = async (tenant: Tenant) => {
    currentTenant.value = tenant;
    await storageAdapter.setItem(StorageKey.CURRENT_TENANT, tenant);
  };

  /**
   * 清除租户上下文
   */
  const clearTenant = async () => {
    currentTenant.value = null;
    tenants.value = [];
    await storageAdapter.removeItem(StorageKey.CURRENT_TENANT);
  };

  /**
   * 从存储初始化租户
   */
  const initTenant = async () => {
    const storedTenant = await storageAdapter.getItem<Tenant>(StorageKey.CURRENT_TENANT);
    if (storedTenant) {
      currentTenant.value = storedTenant;
    }
  };

  return {
    // State
    currentTenant,
    tenants,
    loading,

    // Computed
    tenantId,
    tenantName,
    tenantCode,

    // Actions
    setTenantFromUser,
    fetchTenant,
    fetchTenants,
    switchTenant,
    clearTenant,
    initTenant,
  };
});