<?php

define('WPRSS_TRANSIENT_NAME_IS_REIMPORTING', 'is_reimporting');

/**
 * Returns whether or not the feed source will forcefully fetch the next fetch,
 * ignoring whether or not it is paused or not.
 *
 * @since 3.7
 *
 * @param int $source_id The ID of the feed source
 *
 * @return boolean
 */
function wprss_feed_source_force_next_fetch($source_id)
{
    $force = get_post_meta($source_id, 'wprss_force_next_fetch', true);

    return ($force !== '');
}

/**
 * Change the default feed cache recreation period to 2 hours
 *
 * Probably not needed since we are now disabling caching altogether
 *
 * @since 2.1
 */
function wprss_feed_cache_lifetime($seconds)
{
    return 1; // one second
}

/**
 * Disable caching of feeds in transients, we don't need it as we are storing them in the wp_posts table
 *
 * @since 3.0
 */
function wprss_do_not_cache_feeds(&$feed)
{
    if ($feed instanceof \SimplePie\SimplePie) {
        $feed->enable_cache(false);
    } else { 
        $feed->enable_cache(false);
    }
}

/**
 * Parameters for query to get all feed sources
 *
 * @since 3.0
 */
function wprss_get_all_feed_sources()
{
    $queryArgs = apply_filters(
        'wprss_get_all_feed_sources',
        [
            'post_type' => 'wprss_feed',
            'post_status' => 'publish',
            'cache_results' => false,   // Disable caching, used for one-off queries
            'no_found_rows' => true,    // We don't need pagination, so disable it
            'posts_per_page' => -1,
        ]
    );

    return new WP_Query($queryArgs);
}

/**
 * Retrieves the query to use for retrieving imported items.
 *
 * @since 4.17.4
 */
function wprss_get_imported_items_query($source_id = null)
{
    $args = [
        'post_type' => array_values(get_post_types()),
        'post_status' => 'any',
        'cache_results' => false,
        'no_found_rows' => true,
        'posts_per_page' => -1,
        'ignore_sticky_posts' => 'true',
        'orderby' => 'date',
        'order' => 'DESC',
        'meta_query' => [
            'relation' => 'AND',
        ],
        'suppress_filters' => 1,
    ];

    if ($source_id !== null) {
        $args['meta_query'][] = [
            'key' => 'wprss_feed_id',
            'value' => (string) $source_id,
            'compare' => '=',
        ];
    } else {
        $args['meta_query'][] = [
            'key' => 'wprss_feed_id',
            'compare' => 'EXISTS',
        ];
    }

    return apply_filters('wprss_get_feed_items_for_source_args', $args, $source_id);
}

/**
 * Queries for imported items.
 *
 * @since 4.17.4
 */
function wprss_get_imported_items($source_id = null)
{
    return new WP_Query(wprss_get_imported_items_query($source_id));
}

/**
 * Returns all the feed items of a source.
 *
 * @since 3.8
 */
function wprss_get_feed_items_for_source($source_id)
{
    return wprss_get_imported_items($source_id);
}

/** Checks if a permalink exists in the database. */
function wprss_permalink_exists($permalink) {
    global $wpdb;

    $numRows = $wpdb->query(
        $wpdb->prepare(
            "SELECT `meta_value`
            FROM {$wpdb->postmeta}
            WHERE (`meta_key` = 'wprss_item_permalink' AND `meta_value` = %s)",
            $permalink
        )
    );

    return !!$numRows;
}

/** Checks if a GUID exists in the database. */
function wprss_guid_exists($guid) {
    global $wpdb;

    $numRows = $wpdb->query(
        $wpdb->prepare(
            "SELECT `meta_value`
            FROM {$wpdb->postmeta}
            WHERE (`meta_key` = 'wprss_item_guid' AND `meta_value` = %s)",
            $guid
        )
    );

    return !!$numRows;
}

/**
 * Checks if an item title exists in the database.
 *
 * @since 4.14
 *
 * @param string $title The title to search for.
 *
 * @return bool True if the title exists, false if not.
 */
function wprss_item_title_exists($title)
{
    global $wpdb;

    $numRows = $wpdb->query(
        $wpdb->prepare(
            "SELECT p.`post_title`
            FROM {$wpdb->posts} AS p
            JOIN {$wpdb->postmeta} AS q ON p.`ID` = q.`post_id`
            WHERE q.`meta_key` = 'wprss_feed_id' AND p.`post_title` = %s",
            [html_entity_decode($title)]
        )
    );

    return !!$numRows;
}

add_action('publish_wprss_feed', 'wprss_fetch_insert_feed_items', 10);
/**
 * Fetches feed items from source provided and inserts into db
 *
 * This function is used when inserting or un-trashing a feed source, it only gets feeds from that particular source.
 *
 * @since 3.0
 */
function wprss_fetch_insert_feed_items($post_id)
{
    wp_schedule_single_event(time(), 'wprss_fetch_single_feed_hook', [$post_id]);
}

/**
 * Returns the image of the feed.
 * The reason this function exists is for add-ons to be able to detect if the plugin core
 * supports feed image functionality through a simple function_exists() call.
 *
 * @since 1.0
 *
 * @param int $source_id The ID of the feed source
 *
 * @return string The link to the feed image
 */
function wprss_get_feed_image($source_id)
{
    return get_post_meta($source_id, 'wprss_feed_image', true);
}

add_action('post_updated', 'wprss_updated_feed_source', 10, 3);
/**
 * This function is triggered just after a post is updated.
 * It checks if the updated post is a feed source, and carries out any
 * updating necessary.
 *
 * @since 3.3
 */
function wprss_updated_feed_source($post_ID, $post_after, $post_before)
{
    // Check if the post is a feed source and is published

    if (($post_after->post_type == 'wprss_feed') && ($post_after->post_status == 'publish')) {
        if (isset($_POST['wprss_url']) && !empty($_POST['wprss_url'])) {
            $url = $_POST['wprss_url'];
            $feed = wprss_fetch_feed($url, $post_ID);
            if ($feed !== null && !is_wp_error($feed)) {
                update_post_meta($post_ID, 'wprss_site_url', $feed->get_permalink());
                update_post_meta($post_ID, 'wprss_feed_image', $feed->get_image_url());
            }
        }

        if (isset($_POST['wprss_limit']) && !empty($_POST['wprss_limit'])) {
            // Checking feed limit change
            // Get the limit currently saved in db, and limit in POST request
            //$limit = get_post_meta( $post_ID, 'wprss_limit', true );
            $limit = $_POST['wprss_limit'];
            // Get all feed items for this source
            $feed_sources = new WP_Query(
                [
                    'post_type' => 'wprss_feed_item',
                    'post_status' => 'publish',
                    'cache_results' => false,   // Disable caching, used for one-off queries
                    'no_found_rows' => true,    // We don't need pagination, so disable it
                    'posts_per_page' => -1,
                    'orderby' => 'date',
                    'order' => 'ASC',
                    'meta_query' => [
                        [
                            'key' => 'wprss_feed_id',
                            'value' => $post_ID,
                            'compare' => 'LIKE',
                        ],
                    ],
                ]
            );
            // If the limit is smaller than the number of found posts, delete the feed items
            // and re-import, to ensure that most recent feed items are present.
            $difference = intval($feed_sources->post_count) - intval($limit);
            if ($difference > 0) {
                // Loop and delete the excess feed items
                while ($feed_sources->have_posts() && $difference > 0) {
                    $feed_sources->the_post();
                    wp_delete_post(get_the_ID(), true);
                    $difference--;
                }
            }
        }
    }
}

add_action('added_post_meta', 'wprss_update_feed_meta', 10, 4);
add_action('updated_post_meta', 'wprss_update_feed_meta', 10, 4);
/**
 * This function is run whenever a post is saved or updated.
 *
 * @since 3.4
 */
function wprss_update_feed_meta($meta_id, $post_id, $meta_key, $meta_value)
{
    $post = get_post($post_id);
    if ($post !== null && $post->post_status === 'publish' && $post->post_type === 'wprss_feed') {
        if ($meta_key === 'wprss_url') {
            wprss_change_fb_url($post_id, $meta_value);
        }
    }
}

function wprss_change_fb_url($post_id, $url)
{
    # Check if url begins with a known facebook hostname.
    if (stripos($url, 'http://facebook.com') === 0
        || stripos($url, 'http://www.facebook.com') === 0
        || stripos($url, 'https://facebook.com') === 0
        || stripos($url, 'https://www.facebook.com') === 0
    ) {
        # Generate the new URL to FB Graph
        $com_index = stripos($url, '.com');
        $fb_page = substr($url, $com_index + 4); # 4 = length of ".com"
        $fb_graph_url = 'https://graph.facebook.com' . $fb_page;
        # Contact FB Graph and get data
        $response = wp_remote_get($fb_graph_url);
        # If the response successful and has a body
        if (!is_wp_error($response) && isset($response['body'])) {
            # Parse the body as a JSON string
            $json = json_decode($response['body'], true);
            # If an id is present ...
            if (isset($json['id'])) {
                # Generate the final URL for this feed and update the post meta
                $final_url = "https://www.facebook.com/feeds/page.php?format=rss20&id=" . $json['id'];
                update_post_meta($post_id, 'wprss_url', $final_url, $url);
            }
        }
    }
}

add_action('trash_wprss_feed', 'wprss_delete_feed_items');   // maybe use wp_trash_post action? wp_trash_wprss_feed
/**
 * Delete feed items on trashing of corresponding feed source
 *
 * @since 2.0
 */
function wprss_delete_feed_items($source_id)
{
    $force_delete = apply_filters('wprss_force_delete_when_by_source', true);

    // WPML fix: removes the current language from the query WHERE and JOIN clauses
    global $sitepress;
    if ($sitepress !== null) {
        remove_filter('posts_join', [$sitepress, 'posts_join_filter']);
        remove_filter('posts_where', [$sitepress, 'posts_where_filter']);
    }

    $args = wprss_get_imported_items_query($source_id);
    $items = get_posts($args);

    foreach ($items as $item) {
        wp_delete_post($item->ID, $force_delete);
    }
}

add_action('wprss_delete_all_feed_items_hook', 'wprss_delete_all_feed_items');
/**
 * Delete all feed items
 *
 * @since 3.0
 */
function wprss_delete_all_feed_items()
{
    $args = wprss_get_imported_items_query();
    $items = get_posts($args);

    foreach ($items as $item) {
        wp_delete_post($item->ID, true);
    }
}

/**
 * Marks the feed source as 'updating' (importing).
 *
 * @since 4.6.6
 * @return int The time value set in the 'updating' meta field
 */
function wprss_flag_feed_as_updating($feed_ID)
{
    update_post_meta($feed_ID, 'wprss_feed_is_updating', $start_time = time());
    return $start_time;
}

/**
 * Marks the feed source as 'idle' (not importing).
 *
 * @since 4.6.6
 */
function wprss_flag_feed_as_idle($feed_ID)
{
    update_post_meta($feed_ID, 'wprss_feed_is_updating', '');
}

/**
 * Returns whether the feed source is updating.
 *
 * @param string|int The id of the feed source
 *
 * @return bool TRUE if the feed source is currently updating, FALSE otherwise.
 */
function wprss_is_feed_source_updating($id)
{
    // Get the 'updating' meta field
    $is_updating_meta = get_post_meta($id, 'wprss_feed_is_updating', true);

    // Check if the feed has the 'updating' meta field set
    if ($is_updating_meta === '') {
        // If not, then the feed is not updating
        return false;
    }

    // Get the limit used for the feed
    $limit = get_post_meta($id, 'wprss_limit', true);
    if ($limit === '' || intval($limit) <= 0) {
        $global_limit = wprss_get_general_setting('limit_feed_items_imported');
        $limit = ($global_limit === '' || intval($global_limit) <= 0) ? null : $global_limit;
    }

    // Calculate the allowed maximum time, based on the maximum number of items allowed to be
    // imported from this source.
    // If no limit is used, 60s (1min) is used.
    $single_item_time_limit = wprss_get_feed_fetch_time_limit();
    $allowed_time = $limit === null ? 120 : $single_item_time_limit * intval($limit);

    // Calculate how many seconds have passed since the feed last signalled that it is updating
    $diff = time() - $is_updating_meta;

    // Get the transient that is set when the import function is called and the time of the next scheduled cron
    $is_updating_transient = get_transient('wpra/feeds/importing/' . $id);
    $scheduled = (wprss_get_next_feed_source_update($id) !== false);
    // If more than 5 seconds have passed and the transient is not yet set and the cron was not scheduled
    // then the cron probably failed to be registered
    if ($diff > 5 && !$is_updating_transient && !$scheduled) {
        wprss_flag_feed_as_idle($id);
        update_post_meta(
            $id,
            'wprss_error_last_import',
            __('The plugin failed to schedule a fetch for this feed. Please try again.', 'wprss')
        );

        return false;
    }

    // If the difference is greater than the allowed maximum amount of time, mark the feed as idle.
    if ($diff > $allowed_time) {
        wprss_flag_feed_as_idle($id);
        // Feed is not updating
        return false;
    }

    // Feed is updating
    return true;
}

/**
 * Returns whether the feed source is deleting its feed items.
 *
 * @param string|int The id of the feed source
 *
 * @return bool TRUE if the feed source is currently deleting its items, FALSE otherwise.
 */
function wprss_is_feed_source_deleting($id)
{
    $is_deleting_meta = get_post_meta($id, 'wprss_feed_is_deleting_items', true);

    if ($is_deleting_meta === '') {
        return false;
    }

    $diff = time() - $is_deleting_meta;

    $items = wprss_get_feed_items_for_source($id);
    if ($items->post_count === 0 || $diff > 300) {
        delete_post_meta($id, 'wprss_feed_is_deleting_items');
        return false;
    }

    return true;
}

/**
 * Returns the given parameter as a string. Used in wprss_truncate_posts()
 *
 * @since 3.5.1
 * @return string The given parameter as a string
 */
function wprss_return_as_string($item)
{
    return "'$item'";
}

/**
 * Returns true if the feed item is older than the given timestamp,
 * false otherwise;
 *
 * @since 3.8
 */
function wprss_is_feed_item_older_than($id, $timestamp)
{
    // GET THE DATE
    $age = get_the_time('U', $id);
    if ($age === '') {
        return false;
    }
    // Calculate the age difference
    $difference = $age - $timestamp;
    // Return whether the difference is negative ( the age is smaller than the timestamp )
    return ($difference <= 0);
}

/**
 * Returns the maximum age setting for a feed source.
 *
 * @since 3.8
 */
function wprss_get_max_age_for_feed_source($source_id)
{
    $general_settings = get_option('wprss_settings_general');
    // Get the metadata for age for this feed source
    $age_limit = trim(get_post_meta($source_id, 'wprss_age_limit', true));
    $age_unit = get_post_meta($source_id, 'wprss_age_unit', true);

    // If the meta does not exist, use the global settings
    if ($age_limit === '') {
        $age_limit = trim(wprss_get_general_setting('limit_feed_items_age'));
        $age_unit = wprss_get_general_setting('limit_feed_items_age_unit');
    }

    // If the age limit is an empty string, use no limit
    if ($age_limit === '') {
        return false;
    }

    // Return the timestamp of the max age date
    return strtotime("-$age_limit $age_unit");
}

/**
 * Truncates the items for a single feed source based on its age limit.
 *
 * @since 4.14
 *
 * @param int|WP_Post $source The source ID or post instance.
 */
function wprss_truncate_items_for_source($source)
{
    $id = ($source instanceof WP_Post)
        ? $source->ID
        : $source;

    $logger = wpra_get_logger($id);

    // Get the max age setting for this feed source
    $max_age = wprss_get_max_age_for_feed_source($id);

    // If the data is empty, do not delete
    if ($max_age === false) {
        return;
    }

    // Get all feed items for this source
    $feed_items = wprss_get_feed_items_for_source($id);

    // If there are no feed items, stop
    if (!$feed_items->have_posts()) {
        return;
    }

    // Extend the timeout time limit for the deletion of the feed items
    set_time_limit(wprss_get_item_import_time_limit());

    $logger->debug('Truncating existing items');

    // For each feed item
    while ($feed_items->have_posts()) {
        $feed_items->the_post();
        // If the post is older than the maximum age
        $item_id = get_the_ID();

        if (wprss_is_feed_item_older_than($item_id, $max_age) === true) {
            // Delete the post
            wp_delete_post($item_id, true);
        }
    }

    // Reset feed items query data
    wp_reset_postdata();
}

/**
 * Delete old feed items from the database to avoid bloat.
 * As of 3.8, it uses the new feed age system.
 *
 * @since 3.8
 */
function wprss_truncate_posts()
{
    // Get general settings
    $general_settings = get_option('wprss_settings_general');
    // Get all feed sources
    $feed_sources = wprss_get_all_feed_sources();

    // Check if there are feed sources
    if ($feed_sources->have_posts()) {
        // Truncate items for each feed source
        while ($feed_sources->have_posts()) {
            $feed_sources->the_post();
            wprss_truncate_items_for_source(get_the_ID());
        }
        // Reset feed sources query data
        wp_reset_postdata();
    }

    // If the filter to use the fixed limit is enabled, call the old truncation function
    if (apply_filters('wprss_use_fixed_feed_limit',
            false) === true && isset($general_settings['limit_feed_items_db'])) {
        wprss_old_truncate_posts();
    }
}

/**
 * The old truncation function.
 * This truncation method uses the deprecated fixed feed limit.
 *
 * @since 2.0
 */
function wprss_old_truncate_posts()
{
    global $wpdb;
    $general_settings = get_option('wprss_settings_general');

    if ($general_settings['limit_feed_items_db'] == 0) {
        return;
    }

    // Set your threshold of max posts and post_type name
    $threshold = $general_settings['limit_feed_items_db'];
    $post_types = apply_filters('wprss_truncation_post_types', ['wprss_feed_item']);
    $post_types_str = array_map('wprss_return_as_string', $post_types);

    $post_type_list = implode(',', $post_types_str);

    // Query post type
    // $wpdb query allows me to select specific columns instead of grabbing the entire post object.
    $query = "
            SELECT ID, post_title FROM $wpdb->posts
            WHERE post_type IN ($post_type_list)
            AND post_status = 'publish'
            ORDER BY post_modified DESC
        ";

    $results = $wpdb->get_results($query);

    // Check if there are any results
    $i = 0;
    if (count($results)) {
        foreach ($results as $post) {
            $i++;

            // Skip any posts within our threshold
            if ($i <= $threshold) {
                continue;
            }

            // Let the WordPress API do the heavy lifting for cleaning up entire post trails
            $purge = wp_delete_post($post->ID, true);
        }
    }
}

add_filter('wprss_insert_post_item_conditionals', 'wprss_check_feed_item_date_on_import', 2, 3);
/**
 * When a feed item is imported, it's date is compared against the max age of it's feed source.
 *
 * @since 3.8
 */
function wprss_check_feed_item_date_on_import($item, $source, $permalink)
{
    if ($item === null) {
        return null;
    }

    // Get the age of the item and the max age setting for its feed source
    $age = $item->get_date('U');
    $max_age = wprss_get_max_age_for_feed_source($source);

    // If the age is not a valid timestamp, and the max age setting is disabled, return the item
    if ($age === '' || $age === null || $max_age === false || $max_age === null) {
        return $item;
    }

    // Calculate the age difference
    $difference = $age - $max_age;

    if ($difference <= 0) {
        wpra_get_logger()->debug('Item "{0}" was rejected by age limit settings.', [
            $item->get_title(),
        ]);

        return null;
    } else {
        return $item;
    }
}

/**
 * Deletes all imported feeds.
 *
 * @since 3.0
 */
function wprss_feed_reset()
{
    wp_schedule_single_event(time(), 'wprss_delete_all_feed_items_hook');
}

function wprss_schedule_reimport_all($deleted_ids)
{
    if (!get_transient(WPRSS_TRANSIENT_NAME_IS_REIMPORTING)) {
        return;
    }

    wprss_log('Re-import scheduled...', __FUNCTION__, WPRSS_LOG_LEVEL_SYSTEM);
    delete_transient(WPRSS_TRANSIENT_NAME_IS_REIMPORTING);
    wprss_fetch_insert_all_feed_items(true);
}
