// 文件节点类型
export const NODE_TYPES = {
  FOLDER: 'folder',
  FILE: 'file'
};

// 后端 API 基础地址（可以通过 Vite 环境变量覆盖）
// 如果为空，则使用相对路径（前后端同域名部署）
const API_BASE = import.meta.env.VITE_API_BASE || '';
const USE_RELATIVE_PATH = !API_BASE || API_BASE.trim() === '';

console.log('[MengyaNote] API配置:', {
  API_BASE: API_BASE || '(相对路径)',
  USE_RELATIVE_PATH
});

// 通用的fetch封装，带超时和重试
async function fetchWithTimeout(url, options = {}, timeout = 10000) {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeout);

  try {
    const response = await fetch(url, {
      ...options,
      signal: controller.signal,
    });
    clearTimeout(timeoutId);
    return response;
  } catch (error) {
    clearTimeout(timeoutId);
    if (error.name === 'AbortError') {
      throw new Error('请求超时，请检查网络连接');
    }
    throw error;
  }
}

// 从 FastAPI 后端读取目录树
export async function readDirectoryTree() {
  const apiUrl = USE_RELATIVE_PATH ? '/api/tree' : `${API_BASE}/api/tree`;
  console.log('[MengyaNote] 请求目录树:', apiUrl);
  
  try {
    const res = await fetchWithTimeout(apiUrl, {}, 15000);
    
    if (!res.ok) {
      throw new Error(`服务器返回错误: ${res.status} ${res.statusText}`);
    }
    
    const data = await res.json();
    console.log('[MengyaNote] 目录树数据获取成功');

    // 递归添加 isExpanded 属性，保持与原有前端逻辑兼容
    function addExpandedProperty(nodes) {
      return nodes.map(node => ({
        ...node,
        isExpanded: false,
        children: node.children ? addExpandedProperty(node.children) : []
      }));
    }

    return addExpandedProperty(data);
  } catch (error) {
    console.error('[MengyaNote] 加载目录树失败:', error);
    
    // 返回友好的错误提示
    if (error.message.includes('Failed to fetch') || error.message.includes('NetworkError')) {
      throw new Error('无法连接到服务器，请检查:\n1. 后端服务是否运行\n2. API地址是否正确\n3. 网络连接是否正常');
    }
    
    throw new Error(`加载目录失败: ${error.message}`);
  }
}

function adminApiUrl(path) {
  if (USE_RELATIVE_PATH) {
    return path.startsWith('/') ? path : `/${path}`;
  }
  const base = API_BASE.endsWith('/') ? API_BASE.slice(0, -1) : API_BASE;
  return `${base}${path.startsWith('/') ? path : `/${path}`}`;
}

function parseApiError(res, body) {
  const d = body?.detail;
  if (typeof d === 'string') return d;
  if (Array.isArray(d)) return d.map((x) => x.msg || String(x)).join(', ');
  return `请求失败 ${res.status}`;
}

/** 管理员登录（仅校验 token，密钥不落前端代码） */
export async function adminLogin(token) {
  const url = adminApiUrl('/api/admin/login');
  const res = await fetchWithTimeout(
    url,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ token }),
    },
    15000
  );
  const body = await res.json().catch(() => ({}));
  if (!res.ok) {
    throw new Error(parseApiError(res, body));
  }
  return body;
}

/** 获取忽略文件夹列表 */
export async function fetchIgnoreList(token) {
  const url = adminApiUrl('/api/admin/ignore');
  const res = await fetchWithTimeout(
    url,
    {
      headers: { 'X-Admin-Token': token },
    },
    15000
  );
  const body = await res.json().catch(() => ({}));
  if (!res.ok) {
    throw new Error(parseApiError(res, body));
  }
  return body;
}

/** 添加忽略文件夹 */
export async function addIgnoreFolder(token, name) {
  const url = adminApiUrl('/api/admin/ignore');
  const res = await fetchWithTimeout(
    url,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-Admin-Token': token,
      },
      body: JSON.stringify({ name }),
    },
    15000
  );
  const body = await res.json().catch(() => ({}));
  if (!res.ok) {
    throw new Error(parseApiError(res, body));
  }
  return body;
}

/** 重命名忽略项 */
export async function updateIgnoreFolder(token, oldName, newName) {
  const url = adminApiUrl('/api/admin/ignore');
  const res = await fetchWithTimeout(
    url,
    {
      method: 'PUT',
      headers: {
        'Content-Type': 'application/json',
        'X-Admin-Token': token,
      },
      body: JSON.stringify({ old: oldName, new: newName }),
    },
    15000
  );
  const body = await res.json().catch(() => ({}));
  if (!res.ok) {
    throw new Error(parseApiError(res, body));
  }
  return body;
}

/** 删除忽略项 */
export async function deleteIgnoreFolder(token, name) {
  const url = `${adminApiUrl('/api/admin/ignore')}?${new URLSearchParams({ name })}`;
  const res = await fetchWithTimeout(
    url,
    {
      method: 'DELETE',
      headers: { 'X-Admin-Token': token },
    },
    15000
  );
  const body = await res.json().catch(() => ({}));
  if (!res.ok) {
    throw new Error(parseApiError(res, body));
  }
  return body;
}

// 从 FastAPI 后端读取Markdown文件内容
export async function readMarkdownFile(relativePath) {
  console.log('[MengyaNote] 请求文件:', relativePath);
  
  try {
    // 构建请求URL
    let fetchUrl;
    if (USE_RELATIVE_PATH) {
      // 使用相对路径
      const params = new URLSearchParams({ path: relativePath });
      fetchUrl = `/api/file?${params.toString()}`;
    } else {
      // 使用绝对路径
      const baseUrl = API_BASE.endsWith('/') ? API_BASE.slice(0, -1) : API_BASE;
      const url = new URL(`${baseUrl}/api/file`);
      url.searchParams.set('path', relativePath);
      fetchUrl = url.toString();
    }

    console.log('[MengyaNote] 请求URL:', fetchUrl);
    const res = await fetchWithTimeout(fetchUrl, {}, 15000);
    console.log('[MengyaNote] 响应状态:', res.status);

    if (!res.ok) {
      if (res.status === 404) {
        console.warn('[MengyaNote] 文件未找到:', relativePath);
        return {
          content: `# ${relativePath.split('/').pop().replace('.md', '')}

## 文件未找到

找不到文件：\`${relativePath}\`

可能的原因：
- 文件已被删除或移动
- 文件路径错误
- 后端服务未正确配置

请检查文件是否存在。`,
          metadata: null
        };
      }
      
      throw new Error(`加载文件失败: ${res.status} ${res.statusText}`);
    }

    const data = await res.json();
    console.log('[MengyaNote] 文件内容加载成功, 大小:', data.content?.length, '字节');
    
    return {
      content: data.content || '',
      metadata: {
        wordCount: data.word_count || 0,
        fileSize: data.file_size || 0,
        createdTime: data.created_time || '',
        modifiedTime: data.modified_time || ''
      }
    };
  } catch (error) {
    console.error('[MengyaNote] 加载文件内容失败:', error);
    
    // 返回更友好的错误信息
    const errorMessage = error.message.includes('请求超时') 
      ? '文件加载超时，请重试' 
      : error.message.includes('Failed to fetch')
        ? '网络连接失败，请检查网络'
        : error.message;
    
    return {
      content: `# 加载错误

## 无法加载文件内容

**错误信息:** ${errorMessage}

**请求路径:** \`${relativePath}\`

**解决方案:**
1. 检查网络连接是否正常
2. 确认后端服务正在运行
3. 刷新页面重试
4. 查看浏览器控制台获取详细错误信息`,
      metadata: null
    };
  }
}



// 生成面包屑导航
export function generateBreadcrumbs(filePath) {
  if (!filePath) return [];
  
  const parts = filePath.split('/');
  const breadcrumbs = [];
  
  for (let i = 0; i < parts.length; i++) {
    const name = parts[i];
    const path = parts.slice(0, i + 1).join('/');
    breadcrumbs.push({ name, path });
  }
  
  return breadcrumbs;
}

// 获取文件的标题（从文件名或内容中提取）
export function getFileTitle(filename, content = '') {
  // 首先尝试从内容中提取第一个标题
  const titleMatch = content.match(/^#\s+(.+)$/m);
  if (titleMatch) {
    return titleMatch[1].trim();
  }
  
  // 如果没有找到标题，使用文件名（去掉.md扩展名）
  return filename.replace(/\.md$/, '');
}