tududi/frontend/utils/profileService.ts

import { handleAuthResponse } from "./authUtils";

interface Profile {
  id: number;
  email: string;
  appearance: 'light' | 'dark';
  language: string;
  timezone: string;
  avatar_image: string | null;
  telegram_bot_token: string | null;
  telegram_chat_id: string | null;
  task_summary_enabled: boolean;
  task_summary_frequency: string;
  task_intelligence_enabled: boolean;
  auto_suggest_next_actions_enabled: boolean;
  productivity_assistant_enabled: boolean;
  next_task_suggestion_enabled: boolean;
}

interface SchedulerStatus {
  success: boolean;
  enabled: boolean;
  frequency: string;
  last_run: string | null;
  next_run: string | null;
}

interface TelegramBotInfo {
  username: string;
  polling_status: any;
  chat_url: string;
}

export const fetchProfile = async (): Promise<Profile> => {
  const response = await fetch('/api/profile', {
    credentials: 'include',
    headers: {
      'Accept': 'application/json',
    },
  });
  await handleAuthResponse(response, 'Failed to fetch profile data.');
  return await response.json();
};

export const updateProfile = async (profileData: Partial<Profile>): Promise<Profile> => {
  const response = await fetch('/api/profile', {
    method: 'PATCH',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
    body: JSON.stringify(profileData),
  });
  await handleAuthResponse(response, 'Failed to update profile.');
  return await response.json();
};

export const fetchSchedulerStatus = async (): Promise<SchedulerStatus> => {
  const response = await fetch('/api/profile/task-summary/status', {
    credentials: 'include',
    headers: {
      'Accept': 'application/json',
    },
  });
  await handleAuthResponse(response, 'Failed to fetch scheduler status.');
  return await response.json();
};

export const sendTaskSummaryNow = async (): Promise<any> => {
  const response = await fetch('/api/profile/task-summary/send-now', {
    method: 'POST',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
  });
  await handleAuthResponse(response, 'Failed to send task summary.');
  return await response.json();
};

export const fetchTelegramPollingStatus = async (): Promise<any> => {
  const response = await fetch('/api/telegram/polling-status', {
    credentials: 'include',
    headers: {
      'Accept': 'application/json',
    },
  });
  await handleAuthResponse(response, 'Failed to fetch polling status.');
  return await response.json();
};

export const setupTelegram = async (botToken: string, chatId: string): Promise<TelegramBotInfo> => {
  const response = await fetch('/api/telegram/setup', {
    method: 'POST',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
    body: JSON.stringify({
      bot_token: botToken,
      chat_id: chatId,
    }),
  });
  await handleAuthResponse(response, 'Failed to setup telegram.');
  return await response.json();
};

export const startTelegramPolling = async (): Promise<any> => {
  const response = await fetch('/api/telegram/start-polling', {
    method: 'POST',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
  });
  await handleAuthResponse(response, 'Failed to start telegram polling.');
  return await response.json();
};

export const stopTelegramPolling = async (): Promise<any> => {
  const response = await fetch('/api/telegram/stop-polling', {
    method: 'POST',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
  });
  await handleAuthResponse(response, 'Failed to stop telegram polling.');
  return await response.json();
};

export const testTelegram = async (userId: number, message: string): Promise<any> => {
  const response = await fetch(`/api/telegram/test/${userId}`, {
    method: 'POST',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
    body: JSON.stringify({ text: message }),
  });
  await handleAuthResponse(response, 'Failed to send test message.');
  return await response.json();
};

export const toggleTaskSummary = async (): Promise<any> => {
  const response = await fetch('/api/profile/task-summary/toggle', {
    method: 'POST',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
  });
  await handleAuthResponse(response, 'Failed to toggle task summary.');
  return await response.json();
};

export const updateTaskSummaryFrequency = async (frequency: string): Promise<any> => {
  const response = await fetch('/api/profile/task-summary/frequency', {
    method: 'POST',
    credentials: 'include',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
    body: JSON.stringify({ frequency }),
  });
  await handleAuthResponse(response, 'Failed to update task summary frequency.');
  return await response.json();
};

export type { Profile };

export const getTaskIntelligenceEnabled = async (): Promise<boolean> => {
  try {
    const profile = await fetchProfile();
    return profile.task_intelligence_enabled !== undefined ? profile.task_intelligence_enabled : true;
  } catch (error) {
    console.error('Error fetching task intelligence setting:', error);
    return true; // Default to enabled if we can't fetch the setting
  }
};

export const getAutoSuggestNextActionsEnabled = async (): Promise<boolean> => {
  try {
    const profile = await fetchProfile();
    return profile.auto_suggest_next_actions_enabled !== undefined ? profile.auto_suggest_next_actions_enabled : true;
  } catch (error) {
    console.error('Error fetching auto-suggest next actions setting:', error);
    return true; // Default to enabled if we can't fetch the setting
  }
};

export const getProductivityAssistantEnabled = async (): Promise<boolean> => {
  try {
    const profile = await fetchProfile();
    return profile.productivity_assistant_enabled !== undefined ? profile.productivity_assistant_enabled : true;
  } catch (error) {
    console.error('Error fetching productivity assistant setting:', error);
    return true; // Default to enabled if we can't fetch the setting
  }
};

export const getNextTaskSuggestionEnabled = async (): Promise<boolean> => {
  try {
    const profile = await fetchProfile();
    return profile.next_task_suggestion_enabled !== undefined ? profile.next_task_suggestion_enabled : true;
  } catch (error) {
    console.error('Error fetching next task suggestion setting:', error);
    return true; // Default to enabled if we can't fetch the setting
  }
};