/**
 * SR7 Community Publishing — Firestore data layer.
 * Firebase project: sr7themes-auth
 *
 * Matches the existing SR7Themes pattern: compat SDK, plain classic
 * <script> tag (NOT type="module"), reuses the already-initialized
 * default app via firebase.firestore(). No imports/exports — everything
 * is exposed on window.SR7Community.
 *
 * Load order on any page that needs this:
 *   1. firebase-app-compat.js
 *   2. firebase-auth-compat.js   (if that page also needs auth)
 *   3. firebase-firestore-compat.js
 *   4. your existing login/init script (the one that calls
 *      firebase.initializeApp(firebaseConfig))
 *   5. this file (sr7-community-db.js)
 */
(function () {
  'use strict';

  const db = firebase.firestore();
  const FieldValue = firebase.firestore.FieldValue;

  /* =======================================================================
     Slugs & usernames — uniqueness locks
     ======================================================================= */

  function slugify(title) {
    return (title || '')
      .toLowerCase()
      .trim()
      .replace(/[^a-z0-9\s-]/g, '')
      .replace(/\s+/g, '-')
      .replace(/-+/g, '-')
      .slice(0, 80);
  }

  function claimUsername(uid, username) {
    const clean = (username || '').toLowerCase().trim();
    const usernameRef = db.collection('usernames').doc(clean);
    return db.runTransaction(function (tx) {
      return tx.get(usernameRef).then(function (existing) {
        if (existing.exists) throw new Error('USERNAME_TAKEN');
        tx.set(usernameRef, { uid: uid });
        tx.update(db.collection('users').doc(uid), {
          username: clean,
          updatedAt: FieldValue.serverTimestamp()
        });
      });
    }).then(function () {
      return { ok: true, username: clean };
    }).catch(function (err) {
      if (err.message === 'USERNAME_TAKEN') return { ok: false, reason: 'USERNAME_TAKEN' };
      throw err;
    });
  }

  /* =======================================================================
     Posts — create / autosave / submit / publish
     ======================================================================= */

  function createDraftPost(authorUID, authorName, authorPhoto, title) {
    const postRef = db.collection('posts').doc(); // pre-generate id
    const slugBase = slugify(title || 'untitled');

    return db.runTransaction(function (tx) {
      function tryResolveSlug(candidate, attempt) {
        const slugRef = db.collection('slugs').doc(candidate);
        return tx.get(slugRef).then(function (snap) {
          if (!snap.exists) return { slug: candidate, ref: slugRef };
          if (attempt > 50) throw new Error('SLUG_RESOLUTION_FAILED');
          return tryResolveSlug(slugBase + '-' + (attempt + 1), attempt + 1);
        });
      }

      return tryResolveSlug(slugBase, 1).then(function (resolved) {
        tx.set(resolved.ref, { postId: postRef.id });
        tx.set(postRef, {
          postId: postRef.id,
          authorUID: authorUID,
          authorName: authorName,
          authorPhoto: authorPhoto,
          title: title || '',
          slug: resolved.slug,
          content: '',
          excerpt: '',
          coverImage: '',
          category: '',
          labels: [],
          seoDescription: '',
          canonicalUrl: '',
          status: 'draft',
          rejectionReason: '',
          readingTime: 0,
          views: 0,
          likesCount: 0,
          bookmarksCount: 0,
          commentsCount: 0,
          bloggerPostId: '',
          bloggerUrl: '',
          createdAt: FieldValue.serverTimestamp(),
          updatedAt: FieldValue.serverTimestamp(),
          publishedAt: null
        });
        return { postId: postRef.id, slug: resolved.slug };
      });
    });
  }

  function autosavePost(postId, fields) {
    const allowed = ['title', 'content', 'excerpt', 'coverImage', 'category',
      'labels', 'seoDescription', 'canonicalUrl', 'readingTime'];
    const patch = { updatedAt: FieldValue.serverTimestamp() };
    allowed.forEach(function (key) {
      if (key in fields) patch[key] = fields[key];
    });
    return db.collection('posts').doc(postId).update(patch);
  }

  function submitForReview(postId) {
    return db.collection('posts').doc(postId).update({
      status: 'pending',
      updatedAt: FieldValue.serverTimestamp()
    });
  }

  function publishPost(postId) {
    return db.collection('posts').doc(postId).update({
      status: 'published',
      publishedAt: FieldValue.serverTimestamp(),
      updatedAt: FieldValue.serverTimestamp()
    });
  }

  function rejectPost(postId, reason) {
    return db.collection('posts').doc(postId).update({
      status: 'rejected',
      rejectionReason: reason || '',
      updatedAt: FieldValue.serverTimestamp()
    });
  }

  function getPost(postId) {
    return db.collection('posts').doc(postId).get().then(function (snap) {
      return snap.exists ? snap.data() : null;
    });
  }

  function getPostBySlug(slug) {
    return db.collection('slugs').doc(slug).get().then(function (slugSnap) {
      if (!slugSnap.exists) return null;
      return getPost(slugSnap.data().postId);
    });
  }

  function listPublishedPosts(opts) {
    opts = opts || {};
    const pageSize = opts.pageSize || 12;
    let q = db.collection('posts').where('status', '==', 'published');
    if (opts.category) q = q.where('category', '==', opts.category);
    q = q.orderBy('publishedAt', 'desc').limit(pageSize);
    if (opts.cursor) q = q.startAfter(opts.cursor);
    return q.get().then(function (snap) {
      return {
        posts: snap.docs.map(function (d) { return d.data(); }),
        lastDoc: snap.docs.length ? snap.docs[snap.docs.length - 1] : null
      };
    });
  }

  function listAuthorPosts(authorUID, status) {
    return db.collection('posts')
      .where('authorUID', '==', authorUID)
      .where('status', '==', status)
      .orderBy('updatedAt', 'desc')
      .get()
      .then(function (snap) { return snap.docs.map(function (d) { return d.data(); }); });
  }

  /* =======================================================================
     View dedupe — one increment per viewer per post per day
     ======================================================================= */

  function todayKey() {
    return new Date().toISOString().slice(0, 10);
  }

  function recordViewOnce(postId, viewerKey) {
    const dedupeKey = postId + '_' + viewerKey + '_' + todayKey();
    const dedupeRef = db.collection('postViews').doc(dedupeKey);
    return db.runTransaction(function (tx) {
      return tx.get(dedupeRef).then(function (existing) {
        if (existing.exists) return;
        tx.set(dedupeRef, { postId: postId, viewerKey: viewerKey, createdAt: FieldValue.serverTimestamp() });
        tx.update(db.collection('posts').doc(postId), { views: FieldValue.increment(1) });
      });
    }).catch(function () {
      // Rules reject a duplicate create anyway — safe no-op either way.
    });
  }

  /* =======================================================================
     Likes / bookmarks
     ======================================================================= */

  function toggleLike(uid, postId) {
    const likeRef = db.collection('likes').doc(uid + '_' + postId);
    const postRef = db.collection('posts').doc(postId);
    return db.runTransaction(function (tx) {
      return tx.get(likeRef).then(function (existing) {
        if (existing.exists) {
          tx.delete(likeRef);
          tx.update(postRef, { likesCount: FieldValue.increment(-1) });
          return { liked: false };
        }
        tx.set(likeRef, { uid: uid, postId: postId, createdAt: FieldValue.serverTimestamp() });
        tx.update(postRef, { likesCount: FieldValue.increment(1) });
        return { liked: true };
      });
    });
  }

  function toggleBookmark(uid, postId) {
    const bmRef = db.collection('bookmarks').doc(uid + '_' + postId);
    const postRef = db.collection('posts').doc(postId);
    return db.runTransaction(function (tx) {
      return tx.get(bmRef).then(function (existing) {
        if (existing.exists) {
          tx.delete(bmRef);
          tx.update(postRef, { bookmarksCount: FieldValue.increment(-1) });
          return { bookmarked: false };
        }
        tx.set(bmRef, { uid: uid, postId: postId, createdAt: FieldValue.serverTimestamp() });
        tx.update(postRef, { bookmarksCount: FieldValue.increment(1) });
        return { bookmarked: true };
      });
    });
  }

  /* =======================================================================
     Comments
     ======================================================================= */

  function addComment(postId, author, content, parentCommentId) {
    const postRef = db.collection('posts').doc(postId);
    const commentRef = db.collection('comments').doc();
    return db.runTransaction(function (tx) {
      tx.set(commentRef, {
        postId: postId,
        parentCommentId: parentCommentId || null,
        authorUID: author.uid,
        authorName: author.name,
        authorPhoto: author.photo,
        content: content,
        likesCount: 0,
        status: 'visible',
        createdAt: FieldValue.serverTimestamp()
      });
      tx.update(postRef, { commentsCount: FieldValue.increment(1) });
    });
  }

  function listComments(postId) {
    return db.collection('comments')
      .where('postId', '==', postId)
      .where('status', '==', 'visible')
      .orderBy('createdAt', 'asc')
      .get()
      .then(function (snap) {
        return snap.docs.map(function (d) {
          return Object.assign({ id: d.id }, d.data());
        });
      });
  }

  /* =======================================================================
     Follow / unfollow
     ======================================================================= */

  function toggleFollow(followerUid, followingUid) {
    const followRef = db.collection('follows').doc(followerUid + '_' + followingUid);
    const followerRef = db.collection('users').doc(followerUid);
    const followingRef = db.collection('users').doc(followingUid);
    return db.runTransaction(function (tx) {
      return tx.get(followRef).then(function (existing) {
        if (existing.exists) {
          tx.delete(followRef);
          tx.update(followerRef, { followingCount: FieldValue.increment(-1) });
          tx.update(followingRef, { followersCount: FieldValue.increment(-1) });
          return { following: false };
        }
        tx.set(followRef, { followerUid: followerUid, followingUid: followingUid, createdAt: FieldValue.serverTimestamp() });
        tx.update(followerRef, { followingCount: FieldValue.increment(1) });
        tx.update(followingRef, { followersCount: FieldValue.increment(1) });
        return { following: true };
      });
    });
  }

  /* =======================================================================
     Image URLs — no Firebase Storage (see SCHEMA notes). You host the
     file yourself (GitHub raw / Dropbox direct link) and paste the URL.
     ======================================================================= */

  function isPlausibleImageUrl(url) {
    return typeof url === 'string'
      && /^https:\/\//.test(url)
      && /\.(png|jpe?g|gif|webp|avif)(\?.*)?$/i.test(url);
  }

  function setPostCoverImage(postId, imageUrl) {
    if (!isPlausibleImageUrl(imageUrl)) {
      return Promise.reject(new Error('Please paste a direct https link ending in an image extension.'));
    }
    return autosavePost(postId, { coverImage: imageUrl });
  }

  function setProfilePhoto(uid, imageUrl) {
    if (!isPlausibleImageUrl(imageUrl)) {
      return Promise.reject(new Error('Please paste a direct https link ending in an image extension.'));
    }
    return db.collection('users').doc(uid).update({
      profilePhoto: imageUrl,
      updatedAt: FieldValue.serverTimestamp()
    });
  }

  /* =======================================================================
     Public API
     ======================================================================= */

  window.SR7Community = {
    slugify: slugify,
    claimUsername: claimUsername,
    createDraftPost: createDraftPost,
    autosavePost: autosavePost,
    submitForReview: submitForReview,
    publishPost: publishPost,
    rejectPost: rejectPost,
    getPost: getPost,
    getPostBySlug: getPostBySlug,
    listPublishedPosts: listPublishedPosts,
    listAuthorPosts: listAuthorPosts,
    recordViewOnce: recordViewOnce,
    toggleLike: toggleLike,
    toggleBookmark: toggleBookmark,
    addComment: addComment,
    listComments: listComments,
    toggleFollow: toggleFollow,
    setPostCoverImage: setPostCoverImage,
    setProfilePhoto: setProfilePhoto
  };

})();