Features

export const PostSchema = z.object({
  content: z
    .string()
    .min(1, "Post can not be empty.")
    .max(512, "Post can not be more than 512 characters"),
  image: z.array(z.string()).optional(),
});

export interface Post extends Models.Row {
  content: string;
  image?: string[];
  
  authorId: string;
  authorName: string;
  
  likes: number;
  likedBy: string[];  // Prevents duplicate likes
  
  views: number;
  viewedBy: string[];  // Tracks unique views
  
  commentCount: number;
}

export async function executePost({
  action,
  postId,
  content,
  images,
}: {
  action: "create" | "update" | "delete" | "like" | "view";
  content?: string;
  postId?: string;
  images?: string[];
}) {
  const execution = await functions.createExecution({
    functionId: POSTS_GUARD_FUNCTION_ID,
    body: JSON.stringify({ action, content, postId, images }),
    async: false,
  });
  
  if (execution.status === "failed") {
    throw new Error(`Post execution failed ${execution.errors}`);
  }
  
  return execution;
}

export async function searchPosts(query: string) {
  if (!query.trim()) return fetchPosts();
  
  return await tablesDB.listRows<Post>({
    databaseId: CRIC_TALK_DATABASE_ID,
    tableId: POSTS_TABLES_ID,
    queries: [
      Query.search("content", query),
      Query.orderDesc("views"),
      Query.orderDesc("likes"),
      Query.orderDesc("$createdAt"),
    ],
  });
}

export const RoomSchema = z.object({
  teams: z.array(
    z
      .string()
      .min(3, "Team name must be at least 3 characters.")
      .max(8, "Team name can not be more than 8 characters"),
  ),
  
  startTime: z.string().min(1, "Invalid room start time."),
  endTime: z.string().min(1, "Invalid room end time.").optional(),
  
  matchType: z
    .enum(["ODI", "TEST", "T20"], "Match type must be ODI, TEST or T20.")
    .transform((t) => t.toLowerCase()),
  
  isLocked: z.boolean("Invalid chat lock option."),
});

const updatedRooms: Room[] = rooms.map((item: Room) => {
  let status: "upcoming" | "live" | "finished";
  const now = Date.now();
  const start = new Date(item.startTime).getTime();
  const end = new Date(item.endTime || "").getTime();
  
  if (end < now) {
    status = "finished";
  } else if (start > now) {
    status = "upcoming";
  } else {
    status = "live";
  }
  
  return { ...item, status };
});

export interface UserStats extends Models.Row {
  username: string;
  messageCount: number;
}

// Fetch leaderboard data
const data = await functions.createExecution({
  functionId: process.env.EXPO_PUBLIC_APPWRITE_LEADERBOARD_GUARD_FUNCTION_ID!,
  async: false,
});
const leaderboardData = JSON.parse(data.responseBody).rows;

setUserStatsLeaderboard(leaderboardData);

export async function executeNotification({
  action,
}: {
  action: "fetchByUserId";
}) {
  const execution = await functions.createExecution({
    functionId: NOTIFICATIONS_GUARD_FUNCTION_ID,
    body: JSON.stringify({ action }),
    async: false,
  });
  
  if (execution.status === "failed") {
    throw new Error("Notification execution failed");
  }
  
  return execution;
}

export async function createUserWithEmailAndPassword(
  email: string,
  password: string,
) {
  await account.create({
    userId: ID.unique(),
    email,
    password,
  });
}

export async function loginUserWithEmailAndPassword(
  email: string,
  password: string,
) {
  await account.createEmailPasswordSession({ email, password });
}

const API_ENDPOINT = process.env.EXPO_PUBLIC_APPWRITE_API_ENDPOINT!;
const PROJECT_ID = process.env.EXPO_PUBLIC_APPWRITE_PROJECT_ID!;

export const client = new Client()
  .setEndpoint(API_ENDPOINT)
  .setProject(PROJECT_ID);

export const account = new Account(client);

export async function fetchPostsByUserId(userId: string) {
  return await tablesDB.listRows<Post>({
    databaseId: CRIC_TALK_DATABASE_ID,
    tableId: POSTS_TABLES_ID,
    queries: [Query.equal("authorId", userId), Query.orderDesc("$createdAt")],
  });
}