<?php

namespace MarketSync\Logging;

use MarketSync\Plugin_Uploads;

if ( ! defined( 'ABSPATH' ) ) {
    exit;
}

/**
 * Daily log files owned by the plugin, kept out of WordPress's shared debug.log
 * so they can be rotated and pruned on our own schedule.
 *
 * They live in a sub directory of the plugin's uploads folder — see
 * Plugin_Uploads, which owns that folder, the site-specific suffix and the
 * guard files. This class owns only what is specific to logs: the channel sub
 * directories, the daily file names and the retention sweep.
 */
final class Log_File {

    public const FILE_PREFIX = 'market-sync-';
    public const FILE_SUFFIX = '.log';

    private const DIRECTORY_PREFIX = 'logs-';

    /**
     * Passed to Plugin_Uploads::suffix(). Spelled out rather than composed so
     * the hash input stays fixed: changing it renames the directory and strands
     * every existing log file.
     */
    private const DIRECTORY_LABEL = 'market-sync-logs';

    public static function append( string $line, string $channel ): void {
        $directory = self::directory( $channel );

        if ( '' === $directory ) {
            return;
        }

        // Best-effort: a full disk or a read-only mount must never break a sync.
        @file_put_contents( // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_file_put_contents, WordPress.PHP.NoSilencedErrors.Discouraged
            self::file_path( $directory, self::today() ),
            $line . PHP_EOL,
            FILE_APPEND | LOCK_EX
        );
    }

    /**
     * Base directory, or the sub directory of a single channel when given one.
     */
    public static function directory( string $channel = '' ): string {
        $base = self::base_directory();

        if ( '' === $base ) {
            return '';
        }

        $directory = '' === $channel ? $base : $base . '/' . self::channel_slug( $channel );

        if ( is_dir( $directory ) ) {
            return $directory;
        }

        if ( ! wp_mkdir_p( $directory ) ) {
            return '';
        }

        // Only reached when the directory was just created, so the guard files
        // cost nothing on the hot path. The plugin root is guarded as well: an
        // indexable parent would leak the suffixed folder name.
        Plugin_Uploads::protect( Plugin_Uploads::root() );
        Plugin_Uploads::protect( $base );

        if ( $directory !== $base ) {
            Plugin_Uploads::protect( $directory );
        }

        return $directory;
    }

    public static function path_for( string $date, string $channel ): string {
        $directory = self::directory( $channel );

        return '' === $directory ? '' : self::file_path( $directory, $date );
    }

    private static function file_path( string $directory, string $date ): string {
        return trailingslashit( $directory ) . self::FILE_PREFIX . $date . self::FILE_SUFFIX;
    }

    /**
     * The log root, directly under the plugin's uploads folder. '' when uploads
     * are unavailable — logging is best-effort and stays silent in that case.
     */
    private static function base_directory(): string {
        $root = Plugin_Uploads::root();

        return '' === $root
            ? ''
            : $root . '/' . self::DIRECTORY_PREFIX . Plugin_Uploads::suffix( self::DIRECTORY_LABEL );
    }

    private static function channel_slug( string $channel ): string {
        $slug = sanitize_key( str_replace( '_', '-', $channel ) );

        return '' === $slug ? 'general' : $slug;
    }

    /**
     * Delete log files older than the retention window.
     *
     * @return string[] Names of the deleted files.
     */
    public static function cleanup( int $retention_days ): array {
        $retention_days = max( 1, $retention_days );
        $oldest_kept    = gmdate( 'Y-m-d', strtotime( '-' . $retention_days . ' days', self::now() ) );
        $deleted        = [];

        foreach ( self::files() as $file ) {
            $date = self::date_from_path( $file );

            if ( null === $date || $date >= $oldest_kept ) {
                continue;
            }

            if ( @unlink( $file ) ) { // phpcs:ignore WordPress.WP.AlternativeFunctions.unlink_unlink, WordPress.PHP.NoSilencedErrors.Discouraged
                // Keep the channel in the name so the maintenance log stays readable.
                $deleted[] = ltrim( str_replace( self::base_directory(), '', $file ), '/' );
            }
        }

        return $deleted;
    }

    /**
     * Remove every log file and the directory itself. Used on uninstall.
     */
    public static function purge(): void {
        $root = Plugin_Uploads::root();

        if ( '' === $root || ! is_dir( $root ) ) {
            return;
        }

        // Globbed rather than taken from base_directory(): a rotated salt
        // changes the suffix, and a directory stranded by an older one has to
        // go as well.
        $log_directories = glob( trailingslashit( $root ) . self::DIRECTORY_PREFIX . '*', GLOB_ONLYDIR );

        foreach ( is_array( $log_directories ) ? $log_directories : [] as $base ) {
            $channels = glob( trailingslashit( $base ) . '*', GLOB_ONLYDIR );
            $channels = is_array( $channels ) ? $channels : [];

            // Everything inside our own directory goes, not only files matching
            // the log pattern: a single leftover would keep the directory alive
            // forever. The sweep covers the index.php and .htaccess guards too.
            foreach ( array_merge( $channels, [ $base ] ) as $directory ) {
                Plugin_Uploads::delete_files_in( $directory );
            }

            // Channel sub directories first, the base can only go once empty.
            foreach ( $channels as $channel ) {
                @rmdir( $channel ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_rmdir, WordPress.PHP.NoSilencedErrors.Discouraged
            }

            @rmdir( $base ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_rmdir, WordPress.PHP.NoSilencedErrors.Discouraged
        }

        // The root is shared with the catalog exports, so it is not ours to
        // remove outright — it goes only once nothing else is left in it.
        Plugin_Uploads::remove_root_if_empty();
    }

    /**
     * Every log file across all channels.
     *
     * @return string[] Absolute paths, oldest first.
     */
    public static function files(): array {
        $base = self::base_directory();

        if ( '' === $base || ! is_dir( $base ) ) {
            return [];
        }

        $matches = glob( trailingslashit( $base ) . '*/' . self::FILE_PREFIX . '*' . self::FILE_SUFFIX );
        $files   = is_array( $matches ) ? $matches : [];

        sort( $files );

        return $files;
    }

    private static function date_from_path( string $path ): ?string {
        $name = basename( $path, self::FILE_SUFFIX );
        $date = substr( $name, strlen( self::FILE_PREFIX ) );

        return 1 === preg_match( '/^\d{4}-\d{2}-\d{2}$/', $date ) ? $date : null;
    }

    private static function today(): string {
        return gmdate( 'Y-m-d', self::now() );
    }

    private static function now(): int {
        return (int) current_time( 'timestamp', true );
    }

}