sexy/packages/frontend/src/lib/services.ts

import { gql, GraphQLClient } from "graphql-request";
import { apiUrl, getGraphQLClient } from "$lib/api";
import type {
  Analytics,
  Article,
  CurrentUser,
  Model,
  Recording,
  Stats,
  User,
  Video,
  VideoLikeStatus,
  VideoLikeResponse,
  VideoPlayResponse,
} from "$lib/types";
import { logger } from "$lib/logger";

// Helper to log API calls
async function loggedApiCall<T>(
  operationName: string,
  operation: () => Promise<T>,
  context?: Record<string, unknown>,
): Promise<T> {
  const startTime = Date.now();

  try {
    logger.debug(`🔄 API: ${operationName}`, { context });
    const result = await operation();
    const duration = Date.now() - startTime;
    logger.info(`✅ API: ${operationName} succeeded`, { duration, context });
    return result;
  } catch (error) {
    const duration = Date.now() - startTime;
    logger.error(`❌ API: ${operationName} failed`, {
      duration,
      context,
      error: error instanceof Error ? error : new Error(String(error)),
    });
    throw error;
  }
}

// For server-side auth checks: forward cookie header manually
function getAuthClient(token: string, fetchFn?: typeof globalThis.fetch) {
  return new GraphQLClient(`${apiUrl}/graphql`, {
    fetch: fetchFn || globalThis.fetch,
    headers: { cookie: `session_token=${token}` },
  });
}

// ─── Auth ────────────────────────────────────────────────────────────────────

const ME_QUERY = gql`
  query Me {
    me {
      id
      email
      first_name
      last_name
      artist_name
      slug
      description
      tags
      role
      avatar
      banner
      email_verified
      date_created
    }
  }
`;

export async function isAuthenticated(token: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "isAuthenticated",
    async () => {
      try {
        const client = getAuthClient(token, fetchFn);
        const data = await client.request<{ me: CurrentUser | null }>(ME_QUERY);
        if (data.me) {
          return { authenticated: true, user: data.me };
        }
        return { authenticated: false };
      } catch {
        return { authenticated: false };
      }
    },
    { hasToken: !!token },
  );
}

const LOGIN_MUTATION = gql`
  mutation Login($email: String!, $password: String!) {
    login(email: $email, password: $password) {
      id
      email
      first_name
      last_name
      artist_name
      slug
      description
      tags
      role
      avatar
      banner
      email_verified
      date_created
    }
  }
`;

export async function login(email: string, password: string) {
  return loggedApiCall(
    "login",
    async () => {
      const data = await getGraphQLClient().request<{ login: CurrentUser }>(LOGIN_MUTATION, {
        email,
        password,
      });
      return data.login;
    },
    { email },
  );
}

const LOGOUT_MUTATION = gql`
  mutation Logout {
    logout
  }
`;

export async function logout() {
  return loggedApiCall("logout", async () => {
    await getGraphQLClient().request(LOGOUT_MUTATION);
  });
}

const REGISTER_MUTATION = gql`
  mutation Register($email: String!, $password: String!, $firstName: String!, $lastName: String!) {
    register(email: $email, password: $password, firstName: $firstName, lastName: $lastName)
  }
`;

export async function register(
  email: string,
  password: string,
  firstName: string,
  lastName: string,
) {
  return loggedApiCall(
    "register",
    async () => {
      await getGraphQLClient().request(REGISTER_MUTATION, {
        email,
        password,
        firstName,
        lastName,
      });
    },
    { email, firstName, lastName },
  );
}

const VERIFY_EMAIL_MUTATION = gql`
  mutation VerifyEmail($token: String!) {
    verifyEmail(token: $token)
  }
`;

export async function verify(token: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "verify",
    async () => {
      await getGraphQLClient(fetchFn).request(VERIFY_EMAIL_MUTATION, { token });
    },
    { hasToken: !!token },
  );
}

const REQUEST_PASSWORD_MUTATION = gql`
  mutation RequestPasswordReset($email: String!) {
    requestPasswordReset(email: $email)
  }
`;

export async function requestPassword(email: string) {
  return loggedApiCall(
    "requestPassword",
    async () => {
      await getGraphQLClient().request(REQUEST_PASSWORD_MUTATION, { email });
    },
    { email },
  );
}

const RESET_PASSWORD_MUTATION = gql`
  mutation ResetPassword($token: String!, $newPassword: String!) {
    resetPassword(token: $token, newPassword: $newPassword)
  }
`;

export async function resetPassword(token: string, password: string) {
  return loggedApiCall(
    "resetPassword",
    async () => {
      await getGraphQLClient().request(RESET_PASSWORD_MUTATION, {
        token,
        newPassword: password,
      });
    },
    { hasToken: !!token },
  );
}

// ─── Articles ────────────────────────────────────────────────────────────────

const ARTICLES_QUERY = gql`
  query GetArticles {
    articles {
      id
      slug
      title
      excerpt
      content
      image
      tags
      publish_date
      category
      featured
      author {
        first_name
        last_name
        avatar
        description
      }
    }
  }
`;

export async function getArticles(fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall("getArticles", async () => {
    const data = await getGraphQLClient(fetchFn).request<{ articles: Article[] }>(ARTICLES_QUERY);
    return data.articles;
  });
}

const ARTICLE_BY_SLUG_QUERY = gql`
  query GetArticleBySlug($slug: String!) {
    article(slug: $slug) {
      id
      slug
      title
      excerpt
      content
      image
      tags
      publish_date
      category
      featured
      author {
        first_name
        last_name
        avatar
        description
      }
    }
  }
`;

export async function getArticleBySlug(slug: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getArticleBySlug",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ article: Article | null }>(
        ARTICLE_BY_SLUG_QUERY,
        { slug },
      );
      if (!data.article) throw new Error("Article not found");
      return data.article;
    },
    { slug },
  );
}

// ─── Videos ──────────────────────────────────────────────────────────────────

const VIDEOS_QUERY = gql`
  query GetVideos($modelId: String, $featured: Boolean, $limit: Int) {
    videos(modelId: $modelId, featured: $featured, limit: $limit) {
      id
      slug
      title
      description
      image
      movie
      tags
      upload_date
      premium
      featured
      likes_count
      plays_count
      models {
        id
        artist_name
        slug
        avatar
      }
      movie_file {
        id
        filename
        mime_type
        duration
      }
    }
  }
`;

export async function getVideos(fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall("getVideos", async () => {
    const data = await getGraphQLClient(fetchFn).request<{ videos: Video[] }>(VIDEOS_QUERY);
    return data.videos;
  });
}

export async function getVideosForModel(id: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getVideosForModel",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ videos: Video[] }>(VIDEOS_QUERY, {
        modelId: id,
      });
      return data.videos;
    },
    { modelId: id },
  );
}

export async function getFeaturedVideos(
  limit: number,
  fetchFn: typeof globalThis.fetch = globalThis.fetch,
) {
  return loggedApiCall(
    "getFeaturedVideos",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ videos: Video[] }>(VIDEOS_QUERY, {
        featured: true,
        limit,
      });
      return data.videos;
    },
    { limit },
  );
}

const VIDEO_BY_SLUG_QUERY = gql`
  query GetVideoBySlug($slug: String!) {
    video(slug: $slug) {
      id
      slug
      title
      description
      image
      movie
      tags
      upload_date
      premium
      featured
      likes_count
      plays_count
      models {
        id
        artist_name
        slug
        avatar
      }
      movie_file {
        id
        filename
        mime_type
        duration
      }
    }
  }
`;

export async function getVideoBySlug(slug: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getVideoBySlug",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ video: Video | null }>(
        VIDEO_BY_SLUG_QUERY,
        { slug },
      );
      if (!data.video) throw new Error("Video not found");
      return data.video;
    },
    { slug },
  );
}

// ─── Models ──────────────────────────────────────────────────────────────────

const MODELS_QUERY = gql`
  query GetModels($featured: Boolean, $limit: Int) {
    models(featured: $featured, limit: $limit) {
      id
      slug
      artist_name
      description
      avatar
      banner
      tags
      date_created
      photos {
        id
        filename
      }
    }
  }
`;

export async function getModels(fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall("getModels", async () => {
    const data = await getGraphQLClient(fetchFn).request<{ models: Model[] }>(MODELS_QUERY);
    return data.models;
  });
}

export async function getFeaturedModels(
  limit = 3,
  fetchFn: typeof globalThis.fetch = globalThis.fetch,
) {
  return loggedApiCall(
    "getFeaturedModels",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ models: Model[] }>(MODELS_QUERY, {
        featured: true,
        limit,
      });
      return data.models;
    },
    { limit },
  );
}

const MODEL_BY_SLUG_QUERY = gql`
  query GetModelBySlug($slug: String!) {
    model(slug: $slug) {
      id
      slug
      artist_name
      description
      avatar
      banner
      tags
      date_created
      photos {
        id
        filename
      }
    }
  }
`;

export async function getModelBySlug(slug: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getModelBySlug",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ model: Model | null }>(
        MODEL_BY_SLUG_QUERY,
        { slug },
      );
      if (!data.model) throw new Error("Model not found");
      return data.model;
    },
    { slug },
  );
}

// ─── Profile ─────────────────────────────────────────────────────────────────

const UPDATE_PROFILE_MUTATION = gql`
  mutation UpdateProfile(
    $firstName: String
    $lastName: String
    $artistName: String
    $description: String
    $tags: [String!]
  ) {
    updateProfile(
      firstName: $firstName
      lastName: $lastName
      artistName: $artistName
      description: $description
      tags: $tags
    ) {
      id
      email
      first_name
      last_name
      artist_name
      slug
      description
      tags
      role
      avatar
      banner
      date_created
    }
  }
`;

export async function updateProfile(user: Partial<User>) {
  return loggedApiCall(
    "updateProfile",
    async () => {
      const data = await getGraphQLClient().request<{ updateProfile: User }>(
        UPDATE_PROFILE_MUTATION,
        {
          firstName: user.first_name,
          lastName: user.last_name,
          artistName: user.artist_name,
          description: user.description,
          tags: user.tags,
        },
      );
      return data.updateProfile;
    },
    { userId: user.id },
  );
}

// ─── Stats ───────────────────────────────────────────────────────────────────

const STATS_QUERY = gql`
  query GetStats {
    stats {
      videos_count
      models_count
      viewers_count
    }
  }
`;

export async function getStats(fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall("getStats", async () => {
    const data = await getGraphQLClient(fetchFn).request<{ stats: Stats }>(STATS_QUERY);
    return data.stats;
  });
}

// Stub — Directus folder concept dropped
export async function getFolders(_fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall("getFolders", async () => []);
}

// ─── Files ───────────────────────────────────────────────────────────────────

export async function removeFile(id: string) {
  return loggedApiCall(
    "removeFile",
    async () => {
      // File deletion via REST DELETE /assets/:id (backend handles it)
      const response = await fetch(`${apiUrl}/assets/${id}`, {
        method: "DELETE",
        credentials: "include",
      });
      if (!response.ok) throw new Error(`Failed to delete file: ${response.statusText}`);
    },
    { fileId: id },
  );
}

export async function uploadFile(data: FormData) {
  return loggedApiCall("uploadFile", async () => {
    const response = await fetch(`${apiUrl}/upload`, {
      method: "POST",
      body: data,
      credentials: "include",
    });
    if (!response.ok) throw new Error(`Upload failed: ${response.statusText}`);
    return response.json();
  });
}

// ─── Comments ────────────────────────────────────────────────────────────────

const COMMENTS_FOR_VIDEO_QUERY = gql`
  query CommentsForVideo($videoId: String!) {
    commentsForVideo(videoId: $videoId) {
      id
      comment
      item_id
      user_id
      date_created
      user {
        id
        first_name
        last_name
        avatar
      }
    }
  }
`;

export async function getCommentsForVideo(item: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getCommentsForVideo",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{
        commentsForVideo: {
          id: number;
          comment: string;
          item_id: string;
          user_id: string;
          date_created: string;
          user: {
            id: string;
            first_name: string | null;
            last_name: string | null;
            avatar: string | null;
          } | null;
        }[];
      }>(COMMENTS_FOR_VIDEO_QUERY, { videoId: item });
      return data.commentsForVideo;
    },
    { videoId: item },
  );
}

const CREATE_COMMENT_MUTATION = gql`
  mutation CreateCommentForVideo($videoId: String!, $comment: String!) {
    createCommentForVideo(videoId: $videoId, comment: $comment) {
      id
      comment
      item_id
      user_id
      date_created
    }
  }
`;

export async function createCommentForVideo(item: string, comment: string) {
  return loggedApiCall(
    "createCommentForVideo",
    async () => {
      const data = await getGraphQLClient().request(CREATE_COMMENT_MUTATION, {
        videoId: item,
        comment,
      });
      return data;
    },
    { videoId: item, commentLength: comment.length },
  );
}

export async function countCommentsForModel(
  _user_created: string,
  _fetchFn?: typeof globalThis.fetch,
) {
  // Not directly available in new API, return 0
  return 0;
}

// ─── Tags ────────────────────────────────────────────────────────────────────

export async function getItemsByTag(
  category: "video" | "article" | "model",
  _tag: string,
  fetchFn?: typeof globalThis.fetch,
) {
  return loggedApiCall(
    "getItemsByTag",
    async () => {
      switch (category) {
        case "video":
          return getVideos(fetchFn);
        case "model":
          return getModels(fetchFn);
        case "article":
          return getArticles(fetchFn);
      }
    },
    { category },
  );
}

// ─── Recordings ──────────────────────────────────────────────────────────────

const RECORDINGS_QUERY = gql`
  query GetRecordings(
    $status: String
    $tags: String
    $linkedVideoId: String
    $limit: Int
    $page: Int
  ) {
    recordings(
      status: $status
      tags: $tags
      linkedVideoId: $linkedVideoId
      limit: $limit
      page: $page
    ) {
      id
      title
      description
      slug
      duration
      events
      device_info
      user_id
      status
      tags
      linked_video
      featured
      public
      date_created
      date_updated
    }
  }
`;

export async function getRecordings(fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getRecordings",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ recordings: Recording[] }>(
        RECORDINGS_QUERY,
      );
      return data.recordings;
    },
    {},
  );
}

const CREATE_RECORDING_MUTATION = gql`
  mutation CreateRecording(
    $title: String!
    $description: String
    $duration: Int!
    $events: JSON!
    $deviceInfo: JSON!
    $tags: [String!]
    $status: String
    $linkedVideoId: String
  ) {
    createRecording(
      title: $title
      description: $description
      duration: $duration
      events: $events
      deviceInfo: $deviceInfo
      tags: $tags
      status: $status
      linkedVideoId: $linkedVideoId
    ) {
      id
      title
      description
      slug
      duration
      events
      device_info
      user_id
      status
      tags
      linked_video
      featured
      public
      date_created
      date_updated
    }
  }
`;

export async function createRecording(
  recording: {
    title: string;
    description?: string;
    duration: number;
    events: unknown[];
    device_info: unknown[];
    tags?: string[];
    status?: string;
  },
  fetchFn?: typeof globalThis.fetch,
) {
  return loggedApiCall(
    "createRecording",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ createRecording: Recording }>(
        CREATE_RECORDING_MUTATION,
        {
          title: recording.title,
          description: recording.description,
          duration: recording.duration,
          events: recording.events,
          deviceInfo: recording.device_info,
          tags: recording.tags,
          status: recording.status,
        },
      );
      return data.createRecording;
    },
    { title: recording.title, eventCount: recording.events.length },
  );
}

const DELETE_RECORDING_MUTATION = gql`
  mutation DeleteRecording($id: String!) {
    deleteRecording(id: $id)
  }
`;

export async function deleteRecording(id: string) {
  return loggedApiCall(
    "deleteRecording",
    async () => {
      await getGraphQLClient().request(DELETE_RECORDING_MUTATION, { id });
    },
    { id },
  );
}

const RECORDING_QUERY = gql`
  query GetRecording($id: String!) {
    recording(id: $id) {
      id
      title
      description
      slug
      duration
      events
      device_info
      user_id
      status
      tags
      linked_video
      featured
      public
      date_created
      date_updated
    }
  }
`;

export async function getRecording(id: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getRecording",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ recording: Recording | null }>(
        RECORDING_QUERY,
        { id },
      );
      return data.recording;
    },
    { id },
  );
}

// ─── Video likes & plays ─────────────────────────────────────────────────────

const LIKE_VIDEO_MUTATION = gql`
  mutation LikeVideo($videoId: String!) {
    likeVideo(videoId: $videoId) {
      liked
      likes_count
    }
  }
`;

export async function likeVideo(videoId: string) {
  return loggedApiCall(
    "likeVideo",
    async () => {
      const data = await getGraphQLClient().request<{ likeVideo: VideoLikeResponse }>(
        LIKE_VIDEO_MUTATION,
        { videoId },
      );
      return data.likeVideo;
    },
    { videoId },
  );
}

const UNLIKE_VIDEO_MUTATION = gql`
  mutation UnlikeVideo($videoId: String!) {
    unlikeVideo(videoId: $videoId) {
      liked
      likes_count
    }
  }
`;

export async function unlikeVideo(videoId: string) {
  return loggedApiCall(
    "unlikeVideo",
    async () => {
      const data = await getGraphQLClient().request<{ unlikeVideo: VideoLikeResponse }>(
        UNLIKE_VIDEO_MUTATION,
        { videoId },
      );
      return data.unlikeVideo;
    },
    { videoId },
  );
}

const VIDEO_LIKE_STATUS_QUERY = gql`
  query VideoLikeStatus($videoId: String!) {
    videoLikeStatus(videoId: $videoId) {
      liked
    }
  }
`;

export async function getVideoLikeStatus(videoId: string, fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getVideoLikeStatus",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ videoLikeStatus: VideoLikeStatus }>(
        VIDEO_LIKE_STATUS_QUERY,
        { videoId },
      );
      return data.videoLikeStatus;
    },
    { videoId },
  );
}

const RECORD_VIDEO_PLAY_MUTATION = gql`
  mutation RecordVideoPlay($videoId: String!, $sessionId: String) {
    recordVideoPlay(videoId: $videoId, sessionId: $sessionId) {
      success
      play_id
      plays_count
    }
  }
`;

export async function recordVideoPlay(videoId: string, sessionId?: string) {
  return loggedApiCall(
    "recordVideoPlay",
    async () => {
      const data = await getGraphQLClient().request<{ recordVideoPlay: VideoPlayResponse }>(
        RECORD_VIDEO_PLAY_MUTATION,
        { videoId, sessionId },
      );
      return data.recordVideoPlay;
    },
    { videoId },
  );
}

const UPDATE_VIDEO_PLAY_MUTATION = gql`
  mutation UpdateVideoPlay(
    $videoId: String!
    $playId: String!
    $durationWatched: Int!
    $completed: Boolean!
  ) {
    updateVideoPlay(
      videoId: $videoId
      playId: $playId
      durationWatched: $durationWatched
      completed: $completed
    )
  }
`;

export async function updateVideoPlay(
  videoId: string,
  playId: string,
  durationWatched: number,
  completed: boolean,
) {
  return loggedApiCall(
    "updateVideoPlay",
    async () => {
      await getGraphQLClient().request(UPDATE_VIDEO_PLAY_MUTATION, {
        videoId,
        playId,
        durationWatched,
        completed,
      });
    },
    { videoId, playId, durationWatched, completed },
  );
}

// ─── Analytics ───────────────────────────────────────────────────────────────

const ANALYTICS_QUERY = gql`
  query GetAnalytics {
    analytics
  }
`;

export async function getAnalytics(fetchFn?: typeof globalThis.fetch) {
  return loggedApiCall(
    "getAnalytics",
    async () => {
      const data = await getGraphQLClient(fetchFn).request<{ analytics: Analytics | null }>(
        ANALYTICS_QUERY,
      );
      return data.analytics;
    },
    {},
  );
}