beep/includes/class-replies.php

<?php
if (!defined('ABSPATH')) {
    exit;
}

class Beep_Replies {

    public static function init() {
        add_action('rest_api_init', [__CLASS__, 'register_routes']);
    }

    public static function register_routes() {
        register_rest_route('beep/v1', '/post', [
            'methods'             => 'POST',
            'callback'            => [__CLASS__, 'submit_beep'],
            'permission_callback' => [Beep_Likes::class, 'can_interact'],
        ]);

        register_rest_route('beep/v1', '/reply/(?P<id>\d+)', [
            'methods'             => 'POST',
            'callback'            => [__CLASS__, 'submit_reply'],
            'permission_callback' => [Beep_Likes::class, 'can_interact'],
        ]);

        register_rest_route('beep/v1', '/beep/(?P<id>\d+)', [
            'methods'             => 'DELETE',
            'callback'            => [__CLASS__, 'delete_beep'],
            'permission_callback' => function ($req) {
                return current_user_can('delete_post', (int) $req['id']);
            },
        ]);

        register_rest_route('beep/v1', '/reply/(?P<id>\d+)', [
            'methods'             => 'DELETE',
            'callback'            => [__CLASS__, 'delete_reply'],
            'permission_callback' => function () {
                return current_user_can('moderate_comments');
            },
        ]);
    }

    public static function submit_beep($request) {
        $content = trim((string) $request->get_param('content'));
        $length  = function_exists('mb_strlen') ? mb_strlen($content) : strlen($content);

        if ($content === '' || $length > BEEP_CHAR_LIMIT) {
            return new WP_Error('beep_invalid_content',
                'Content must be 1-' . BEEP_CHAR_LIMIT . ' characters.',
                ['status' => 400]);
        }

        $post_id = wp_insert_post([
            'post_type'    => Beep_CPT::POST_TYPE,
            'post_status'  => 'publish',
            'post_author'  => get_current_user_id(),
            'post_content' => wp_kses($content, []),
            'post_title'   => wp_trim_words($content, 8, '...'),
        ], true);

        if (is_wp_error($post_id)) {
            return $post_id;
        }

        if (is_wp_error($post_id)) {
            return $post_id;
        }

        $body = $request->get_json_params();
        $quote_id = isset($body['quote_id']) ? (int) $body['quote_id'] : 0;
        if ($quote_id) {
            Beep_Quotes::create_quote($post_id, $quote_id);
        }

        $gif_url = isset($body['gif_url']) ? esc_url_raw($body['gif_url']) : '';
        if ($gif_url) {
            update_post_meta($post_id, 'beep_gif_url', $gif_url);
        }

        return rest_ensure_response([
            'id'   => $post_id,
            'html' => beep_render_post(get_post($post_id)),
        ]);
    }

    public static function submit_reply($request) {
        $post_id   = (int) $request['id'];
        $content   = trim((string) $request->get_param('content'));
        $parent_id = (int) $request->get_param('parent');
        $length    = function_exists('mb_strlen') ? mb_strlen($content) : strlen($content);

        if (get_post_type($post_id) !== Beep_CPT::POST_TYPE) {
            return new WP_Error('beep_not_a_beep', 'Not a beep.', ['status' => 400]);
        }
        if ($content === '' || $length > BEEP_CHAR_LIMIT) {
            return new WP_Error('beep_invalid_content',
                'Reply must be 1-' . BEEP_CHAR_LIMIT . ' characters.',
                ['status' => 400]);
        }
        // Validate the parent comment belongs to this post if provided.
        if ($parent_id > 0) {
            $parent = get_comment($parent_id);
            if (!$parent || (int) $parent->comment_post_ID !== $post_id) {
                return new WP_Error('beep_bad_parent', 'Invalid parent.', ['status' => 400]);
            }
        }

        $user = wp_get_current_user();

        $approved = get_option('comment_moderation') ? 0 : 1;
        if (get_option('comment_previously_approved')) {
            $prev = get_comments([
                'user_id' => $user->ID,
                'status'  => 'approve',
                'count'   => true,
            ]);
            if (!$prev) {
                $approved = 0;
            }
        }

        $comment_id = wp_insert_comment([
            'comment_post_ID'      => $post_id,
            'comment_author'       => $user->display_name,
            'comment_author_email' => $user->user_email,
            'comment_author_url'   => '',
            'comment_content'      => wp_kses($content, []),
            'comment_type'         => 'comment',
            'comment_parent'       => $parent_id,
            'user_id'              => $user->ID,
            'comment_approved'     => $approved,
        ]);

        if (!$comment_id) {
            return new WP_Error('beep_insert_failed', 'Reply could not be saved.', ['status' => 500]);
        }

        $comment = get_comment($comment_id);
        $pending = ($comment->comment_approved == 0);

        // Depth of this reply for client-side indenting.
        $depth = 0;
        $cur   = $comment;
        while ($cur && (int) $cur->comment_parent > 0 && $depth < 10) {
            $cur = get_comment((int) $cur->comment_parent);
            $depth++;
        }
        $can_interact = Beep_Likes::can_interact();

        return rest_ensure_response([
            'id'      => $comment_id,
            'parent'  => (int) $comment->comment_parent,
            'pending' => $pending,
            'html'    => $pending ? '' : beep_render_reply($comment, [], $depth, $post_id, $can_interact),
        ]);
    }

    public static function delete_beep($request) {
        $post_id = (int) $request['id'];
        if (get_post_type($post_id) !== Beep_CPT::POST_TYPE) {
            return new WP_Error('beep_not_a_beep', 'Not a beep.', ['status' => 400]);
        }
        $deleted = wp_delete_post($post_id, true);
        if (!$deleted) {
            return new WP_Error('beep_delete_failed', 'Could not delete.', ['status' => 500]);
        }
        return rest_ensure_response(['deleted' => true]);
    }

    public static function delete_reply($request) {
        $comment_id = (int) $request['id'];
        $deleted = wp_delete_comment($comment_id, true);
        if (!$deleted) {
            return new WP_Error('beep_delete_failed', 'Could not delete.', ['status' => 500]);
        }
        return rest_ensure_response(['deleted' => true]);
    }

    public static function get_replies($post_id) {
        return get_comments([
            'post_id' => $post_id,
            'status'  => 'approve',
            'order'   => 'ASC',
            'type'    => 'comment',
        ]);
    }

    public static function reply_count($post_id) {
        return (int) get_comments_number($post_id);
    }
}

    /**
     * Get the full conversation/thread for a beep.
     * Returns the root beep and all nested replies in tree order.
     */
    public static function get_thread($post_id, $depth = 0, $max_depth = 10) {
        if ($depth > $max_depth) return [];
        $post = get_post($post_id);
        if (!$post || $post->post_type !== Beep_CPT::POST_TYPE) return [];
        $thread = [self::format_beep_reply($post, $depth)];
        $replies = get_comments([
            'post_id' => $post_id, 'status' => 'approve', 'order' => 'ASC',
            'type' => 'comment', 'number' => 100,
        ]);
        foreach ($replies as $reply) {
            if ($depth < $max_depth) {
                $thread = array_merge($thread, self::get_comment_thread($reply->comment_ID, $depth + 1, $max_depth));
            }
        }
        return $thread;
    }

    private static function get_comment_thread($comment_id, $depth, $max_depth) {
        if ($depth > $max_depth) return [];
        $comment = get_comment($comment_id);
        if (!$comment) return [];
        $result = [self::format_comment_reply($comment, $depth)];
        $children = get_comments([
            'parent' => $comment_id, 'status' => 'approve', 'order' => 'ASC',
            'type' => 'comment', 'number' => 100,
        ]);
        foreach ($children as $child) {
            $result = array_merge($result, self::get_comment_thread($child->comment_ID, $depth + 1, $max_depth));
        }
        return $result;
    }

    public static function format_beep_reply($post, $depth = 0) {
        $author_id = $post->post_author;
        $author    = get_userdata($author_id);
        $avatar    = get_user_meta($author_id, 'beep_avatar', true);
        if (!$avatar) {
            $avatar = 'https://www.gravatar.com/avatar/' . md5(strtolower($author->user_email ?? '')) . '?s=48&d=mp';
        }
        return [
            'id'          => $post->ID,
            'parent_id'   => $post->post_parent ?: null,
            'is_post'     => true,
            'depth'       => $depth,
            'content'     => $post->post_content,
            'time_ago'    => self::time_ago(strtotime($post->post_date)),
            'like_count'  => Beep_Likes::get_count($post->ID, 'post'),
            'reply_count' => self::reply_count($post->ID),
            'author'      => [
                'id'       => $author_id,
                'name'     => $author->display_name ?? 'Unknown',
                'username' => $author->user_login ?? '',
                'avatar'   => $avatar,
            ],
        ];
    }

    public static function format_comment_reply($comment, $depth = 0) {
        $author_id = (int) $comment->user_id;
        $author    = $author_id ? get_userdata($author_id) : null;
        if ($author_id) {
            $avatar = get_user_meta($author_id, 'beep_avatar', true);
            if (!$avatar) {
                $avatar = 'https://www.gravatar.com/avatar/' . md5(strtolower($author->user_email ?? '')) . '?s=48&d=mp';
            }
            $name     = $author->display_name ?? 'Unknown';
            $username = $author->user_login ?? '';
        } else {
            $avatar   = 'https://www.gravatar.com/avatar/?s=48&d=mp';
            $name     = esc_html($comment->comment_author);
            $username = '';
        }
        return [
            'id'          => $comment->comment_ID,
            'parent_id'   => (int) $comment->comment_parent ?: null,
            'is_post'     => false,
            'depth'       => $depth,
            'content'     => $comment->comment_content,
            'time_ago'    => self::time_ago(strtotime($comment->comment_date)),
            'like_count'  => Beep_Likes::get_count($comment->comment_ID, 'reply'),
            'reply_count' => 0,
            'author'      => [
                'id'       => $author_id,
                'name'     => $name,
                'username' => $username,
                'avatar'   => $avatar,
            ],
        ];
    }

    public static function time_ago($timestamp) {
        $diff = time() - $timestamp;
        if ($diff < 0) $diff = 0;
        if ($diff < 60) return $diff . 's';
        if ($diff < 3600) return floor($diff / 60) . 'm';
        if ($diff < 86400) return floor($diff / 3600) . 'h';
        if ($diff < 604800) return floor($diff / 86400) . 'd';
        return gmdate('M j', $timestamp);
    }
}