Source: data/FirestoreMethods.js

import {
	collection,
	doc,
	getDoc,
	setDoc,
	Timestamp,
	updateDoc,
} from 'firebase/firestore';
import { Chat, Message, Trade, User } from './Schemas.js';
import { db } from './Firebase.js';
import FirestoreResponse from './FirestoreResponse.js';

/**
 * Creates a default user document in Firestore if it doesn't already exist.
 *
 * @param {import('firebase/auth').User} firebaseUser - The Firebase Auth user.
 * @returns {Promise<void>}
 */
export async function createUserIfMissing(firebaseUser) {
	if (!firebaseUser) return;

	const userRef = doc(db, 'users', firebaseUser.uid);
	const userSnap = await getDoc(userRef);

	if (!userSnap.exists()) {
		const defaultUser = new User({
			uid: firebaseUser.uid,
			bio: '',
			location: '',
			skillsOffered: [],
			skillsWanted: [],
			rating: 0,
			availability: {
				monday: [],
				tuesday: [],
				wednesday: [],
				thursday: [],
				friday: [],
				saturday: [],
				sunday: [],
			},
		});

		await setDoc(userRef, defaultUser.toObject());
	}
	return;
}

/**
 *
 * @param {import('./Schemas.js').TradeObject} tradeData
 */
export async function postTrade(tradeData) {
	const tradeRef = doc(collection(db, 'trades'));
	const tradeId = tradeRef.id;

	const newTrade = new Trade({
		id: tradeId,
		offererId: tradeData.offererId,
		receiverId: null,
		offeredSkill: tradeData.offeredSkill,
		requestedSkill: tradeData.requestedSkill,
		tradeStatus: 'pending',
		message: tradeData.message ?? '',
	});

	await setDoc(tradeRef, newTrade.toObject());

	return newTrade;
}

/**
 *
 * @param {import('./Schemas.js').Trade} trade - The trade creator
 * @param {import('./Schemas.js').User} user - The accepting user
 * @returns {boolean}
 */
export async function updateTrade(trade, user) {
	try {
		if (user.uid === trade.offererId) return false;

		const tradeRef = doc(db, 'trades', trade.id);

		await updateDoc(tradeRef, {
			tradeStatus: trade.tradeStatus == 'pending' ? 'accepted' : 'pending',
			receiverId: trade.tradeStatus == 'pending' ? user.uid : null,
		});
		return true;
	} catch (error) {
		console.log(error);
		return false;
	}
}

/**
 *
 * @param {import('./Schemas.js').ChatUser} user1 - ChatUser instance of one of the users
 * @param {import('./Schemas.js').ChatUser} user2 - ChatUser instance of one of the users
 */
export async function createNewChat(user1, user2) {
	if (!user1 || !user2) return;
	if (user1 == user2) return;
	try {
		const chatReference = doc(collection(db, 'chats'));

		const chatObject = new Chat({
			id: chatReference.id,
			participant1: user1,
			participant2: user2,
			messages: [],
			status: 'active',
		});

		await setDoc(chatReference, chatObject.toObject());

		return chatObject;
	} catch (error) {
		console.error(error);
		return null;
	}
}
/**
 *
 */
export async function createNewMessage(author, chatId, content) {
	if (!author || !chatId || !content) return;
	try {
		const messagesReference = collection(db, 'chats', chatId, 'messages');
		const messageDoc = doc(messagesReference);

		const msg = new Message({
			author: author,
			chatId: chatId,
			content: content,
			timestamp: Timestamp.now(),
			id: messageDoc.id,
		});
		await setDoc(messageDoc, msg.toObject());
		return new FirestoreResponse({
			success: true,
			error: null,
			data: msg,
			message: 'Ok!',
		});
	} catch (error) {
		console.error(error);
		return new FirestoreResponse(error);
	}
}