import { Dictionary } from 'lodash';
import {
  collection,
  query as createQuery,
  where,
  orderBy,
  limit,
  getDocs,
  doc,
  getDoc,
  startAt,
  endAt,
  startAfter,
  endBefore,
  DocumentReference,
  updateDoc,
  FieldPath,
  WhereFilterOp,
  addDoc,
  deleteDoc,
  setDoc,
  writeBatch,
} from 'firebase/firestore';
// db
import { db } from './firebase';

export const collections = {
  administrator: 'administrators',
  invoice: 'invoices',
  customer: 'customers',
  service: 'services',
  settings: 'settings',
  mail: 'mail',
};

export const documents = {
  settingsCompany: 'company',
  settingsInvoice: 'invoice',
};

type FirebaseDocument = {
  id?: string;
  [key: string]: any;
};

export const collectionRef = (path: string) => collection(db, `${path}`);

export const documentRef = <T>(collectionPath: string, documentId: string) =>
  doc(db, `${collectionPath}/${documentId}`) as DocumentReference<T>;

export const createDocId = (collectionPath: string) => doc(collection(db, collectionPath)).id;

export const createDocument = async <T extends Dictionary<any>>(
  collectionPath: string,
  data?: T
) => {
  const ref = collectionRef(collectionPath);
  const docSnap = await addDoc(ref, data || {});
  return docSnap;
};

interface BatchWriteOperation<T> {
  type: 'set' | 'update' | 'delete';
  docPath: string;
  data?: T;
}

export const firestoreBatch = async <T extends Dictionary<any>>(
  operations: BatchWriteOperation<T>[]
) => {
  const batch = writeBatch(db);
  // Convert the document path to a document reference
  const getDocRef = (path: string) => doc(db, path);

  operations.forEach((operation) => {
    const docRef = getDocRef(operation.docPath);
    switch (operation.type) {
      case 'set':
        batch.set(docRef, operation.data || {}, { merge: true });
        break;
      case 'update':
        batch.update(docRef, operation.data || {});
        break;
      case 'delete':
        batch.delete(docRef);
        break;
      default:
        throw new Error(`Unsupported operation type: ${operation.type}`);
    }
  });

  await batch.commit();
};

interface UpdateOptions {
  merge: boolean;
}

export const generateId = (path: string) => {
  const ref = doc(collectionRef(path));
  return ref.id;
};

export const setDocument = async <T extends Dictionary<any>>(
  collectionPath: string,
  documentId: string,
  data: T,
  options?: UpdateOptions
) => {
  const ref = documentRef(collectionPath, documentId);
  await setDoc(ref, data, {
    ...(options || {}),
    merge: options && options.merge,
  });
};

export const updateDocument = async <T extends FirebaseDocument>(
  collectionPath: string,
  documentId: string,
  data: T
) => {
  const ref = documentRef(collectionPath, documentId);
  await updateDoc(ref, data);
};

export const removeDocument = async (collectionPath: string, documentId: string) => {
  const ref = documentRef(collectionPath, documentId);
  await deleteDoc(ref);
};

type JoinConfig = {
  joinIdField: string;
  joinCollection: string;
  as: string;
};

export type FirestoreQueryParams = {
  where?: [string | FieldPath, WhereFilterOp, any][];
  orderBy?: string | FieldPath;
  direction?: 'asc' | 'desc';
  limit?: number;
  startAt?: any;
  endAt?: any;
  startAfter?: any;
  endBefore?: any;
};

// Function overloads:
async function collectionFetcher<T extends FirebaseDocument>(collectionName: string): Promise<T[]>;

async function collectionFetcher<T extends FirebaseDocument>(
  collectionName: string,
  joinConfig?: JoinConfig,
  queryParams?: FirestoreQueryParams
): Promise<T[]>;

async function collectionFetcher<T extends FirebaseDocument, J extends FirebaseDocument>(
  collectionName: string,
  joinConfig: JoinConfig,
  queryParams?: FirestoreQueryParams
): Promise<(T & Record<typeof joinConfig.as, J>)[]>;

// Function implementation:
async function collectionFetcher<T extends FirebaseDocument, J extends FirebaseDocument>(
  collectionName: string,
  joinConfig?: JoinConfig,
  queryParams?: FirestoreQueryParams
): Promise<T[] | (T & Record<string, J>)[]> {
  let firestoreQuery = createQuery(collection(db, collectionName));

  if (queryParams) {
    if (queryParams.where) {
      queryParams.where.forEach((condition) => {
        firestoreQuery = createQuery(firestoreQuery, where(...condition));
      });
    }

    if (queryParams.orderBy) {
      firestoreQuery = createQuery(
        firestoreQuery,
        orderBy(queryParams.orderBy, queryParams.direction || 'asc')
      );
    }

    if (queryParams.limit) {
      firestoreQuery = createQuery(firestoreQuery, limit(queryParams.limit));
    }

    if (queryParams.startAt) {
      firestoreQuery = createQuery(firestoreQuery, startAt(queryParams.startAt));
    }

    if (queryParams.endAt) {
      firestoreQuery = createQuery(firestoreQuery, endAt(queryParams.endAt));
    }

    if (queryParams.startAfter) {
      firestoreQuery = createQuery(firestoreQuery, startAfter(queryParams.startAfter));
    }

    if (queryParams.endBefore) {
      firestoreQuery = createQuery(firestoreQuery, endBefore(queryParams.endBefore));
    }
  }

  try {
    const snap = await getDocs(firestoreQuery);

    if (!joinConfig) {
      return snap.docs.map((joinDoc) => ({ id: joinDoc.id, ...joinDoc.data() }) as T);
    }

    const joinPromises = snap.docs.map(async (primaryDoc) => {
      const primaryData = { id: primaryDoc.id, ...primaryDoc.data() } as T;
      const joinId = getValueByPath(primaryData, joinConfig.joinIdField);

      if (!joinId) return primaryData;

      const joinDocSnap = await getDoc(doc(db, joinConfig.joinCollection, joinId.toString()));

      return {
        ...primaryData,
        [joinConfig.as]: joinDocSnap.exists() ? (joinDocSnap.data() as J) : undefined,
      } as T & Record<string, J>;
    });

    return await Promise.all(joinPromises);
  } catch (error) {
    console.error('Error fetching data', error);
    throw error;
  }
}

// Document fetcher
async function documentFetcher<T extends FirebaseDocument>(
  collectionName: string,
  docId: string,
  joinConfig?: JoinConfig
): Promise<T | (T & Record<string, any>)> {
  try {
    const docSnapshot = await getDoc(doc(db, collectionName, docId));

    if (!docSnapshot.exists) {
      throw new Error('Document not found');
    }

    const documentData = { id: docSnapshot.id, ...docSnapshot.data() } as T;

    // If no join configuration is provided, simply return the document data.
    if (!joinConfig) {
      return documentData;
    }

    // If a join configuration is provided, fetch the related document.
    const joinDocSnapshot = await getDoc(
      doc(db, joinConfig.joinCollection, documentData[joinConfig.joinIdField])
    );

    if (joinDocSnapshot.exists()) {
      return {
        ...documentData,
        [joinConfig.as]: joinDocSnapshot.data(),
      } as T & Record<string, any>;
    }
    return documentData; // or handle missing join data as you see fit
  } catch (error) {
    console.error('Error fetching document:', error);
    throw error;
  }
}

function getValueByPath(obj: any, path: string): any {
  return path.split('.').reduce((o, key) => o && o[key], obj);
}

export { collectionFetcher, documentFetcher };