<?php

namespace WP_CLI;

use WP_CLI;
use Theme_AutoUpdates_Command;

trait ParseThemeNameInput {

    /**
     * If have optional args ([<theme>...]) and an all option, then check have something to do.
     *
     * @param array  $args Passed-in arguments.
     * @param bool   $all All flag.
     * @param string $verb Optional. Verb to use. Defaults to 'install'.
     * @return array Same as $args if not all, otherwise all slugs.
     * @throws ExitException If neither plugin name nor --all were provided.
     */
    protected function check_optional_args_and_all( $args, $all, $verb = 'install' ) {
        if ( $all ) {
            $args = array_map(
                '\WP_CLI\Utils\get_theme_name',
                array_keys( $this->get_all_themes() )
            );
        }

        if ( empty( $args ) ) {
            if ( ! $all ) {
                WP_CLI::error( 'Please specify one or more themes, or use --all.' );
            }

            $past_tense_verb = Utils\past_tense_verb( $verb );
            WP_CLI::success( "No themes {$past_tense_verb}." ); // Don't error if --all given for BC.
        }

        return $args;
    }

    /**
     * Gets all available themes.
     *
     * Uses the same filter core uses in themes.php to determine which themes
     * should be available to manage through the WP_Themes_List_Table class.
     *
     * @return array
     */
    private function get_all_themes() {
        global $wp_version;
        // Extract the major WordPress version (e.g., "6.3") from the full version string
        list($wp_core_version) = explode( '-', $wp_version );
        $wp_core_version       = implode( '.', array_slice( explode( '.', $wp_core_version ), 0, 2 ) );

        $items              = array();
        $theme_version_info = array();

        if ( is_multisite() ) {
            $site_enabled = get_option( 'allowedthemes' );
            if ( empty( $site_enabled ) ) {
                $site_enabled = array();
            }

            $network_enabled = get_site_option( 'allowedthemes' );
            if ( empty( $network_enabled ) ) {
                $network_enabled = array();
            }
        }

        $all_update_info = $this->get_update_info();
        $checked_themes  = isset( $all_update_info->checked ) ? $all_update_info->checked : array();

        if ( ! empty( $checked_themes ) ) {
            foreach ( $checked_themes as $slug => $version ) {
                $theme_version_info[ $slug ] = $this->is_theme_version_valid( $slug, $version );
            }
        }

        $auto_updates = get_site_option( Theme_AutoUpdates_Command::SITE_OPTION );

        if ( ! is_array( $auto_updates ) ) {
            $auto_updates = [];
        }

        foreach ( wp_get_themes() as $key => $theme ) {
            $stylesheet  = $theme->get_stylesheet();
            $update_info = ( isset( $all_update_info->response[ $stylesheet ] ) && null !== $all_update_info->response[ $theme->get_stylesheet() ] ) ? (array) $all_update_info->response[ $theme->get_stylesheet() ] : null;

            // Unlike plugin update responses, the wordpress.org API does not seem to check and filter themes that don't meet
            // WordPress version requirements into a separate no_updates array
            // Also unlike plugin update responses, the wordpress.org API seems to always include requires AND requires_php
            $requires     = isset( $update_info ) && isset( $update_info['requires'] ) ? $update_info['requires'] : null;
            $requires_php = isset( $update_info ) && isset( $update_info['requires_php'] ) ? $update_info['requires_php'] : null;

            $compatible_php = empty( $requires_php ) || version_compare( PHP_VERSION, $requires_php, '>=' );
            $compatible_wp  = empty( $requires ) || version_compare( $wp_version, $requires, '>=' );

            if ( ! $compatible_php ) {
                $update = 'unavailable';

                $update_unavailable_reason = sprintf(
                    'This update requires PHP version %s, but the version installed is %s.',
                    $requires_php,
                    PHP_VERSION
                );
            } elseif ( ! $compatible_wp ) {
                $update = 'unavailable';

                $update_unavailable_reason = sprintf(
                    'This update requires WordPress version %s, but the version installed is %s.',
                    $requires,
                    $wp_version
                );
            } else {
                $update = $update_info ? 'available' : 'none';
            }

            // For display consistency, get these values from the current plugin file if they aren't in this response
            if ( null === $requires ) {
                $requires = ! empty( $theme->get( 'RequiresWP' ) ) ? $theme->get( 'RequiresWP' ) : '';
            }

            if ( null === $requires_php ) {
                $requires_php = ! empty( $theme->get( 'RequiresPHP' ) ) ? $theme->get( 'RequiresPHP' ) : '';
            }

            $items[ $stylesheet ] = [
                'name'                      => $key,
                'status'                    => $this->get_status( $theme ),
                'update'                    => $update,
                'update_version'            => isset( $update_info['new_version'] ) ? $update_info['new_version'] : null,
                'update_package'            => isset( $update_info['package'] ) ? $update_info['package'] : null,
                'version'                   => $theme->get( 'Version' ),
                'update_id'                 => $stylesheet,
                'title'                     => $theme->get( 'Name' ),
                'description'               => wordwrap( $theme->get( 'Description' ) ),
                'author'                    => $theme->get( 'Author' ),
                'auto_update'               => in_array( $stylesheet, $auto_updates, true ),
                'requires'                  => $requires,
                'requires_php'              => $requires_php,
                'update_unavailable_reason' => isset( $update_unavailable_reason ) ? $update_unavailable_reason : '',
            ];

            // Compare version and update information in theme list.
            if ( isset( $theme_version_info[ $key ] ) && false === $theme_version_info[ $key ] ) {
                $items[ $stylesheet ]['update'] = 'version higher than expected';
            }

            if ( is_multisite() ) {
                if ( ! empty( $site_enabled[ $key ] ) && ! empty( $network_enabled[ $key ] ) ) {
                    $items[ $stylesheet ]['enabled'] = 'network,site';
                } elseif ( ! empty( $network_enabled[ $key ] ) ) {
                    $items[ $stylesheet ]['enabled'] = 'network';
                } elseif ( ! empty( $site_enabled[ $key ] ) ) {
                    $items[ $stylesheet ]['enabled'] = 'site';
                } else {
                    $items[ $stylesheet ]['enabled'] = 'no';
                }
            }
        }

        return $items;
    }

    /**
     * Check if current version of the theme is higher than the one available at WP.org.
     *
     * @param string $slug Theme slug.
     * @param string $version Theme current version.
     *
     * @return bool|string
     */
    protected function is_theme_version_valid( $slug, $version ) {
        // Get Theme Info.
        $theme_info = themes_api( 'theme_information', array( 'slug' => $slug ) );

        // Return empty string for themes not on WP.org.
        if ( is_wp_error( $theme_info ) ) {
            return '';
        }

        // Compare theme version info.
        return ! version_compare( $version, $theme_info->version, '>' );
    }

    /**
     * Get the status for a given theme.
     *
     * @param WP_Theme $theme Theme to get the status for.
     *
     * @return string Status of the theme.
     */
    protected function get_status( $theme ) {
        if ( $this->is_active_theme( $theme ) ) {
            return 'active';
        }

        if ( $theme->get_stylesheet_directory() === get_template_directory() ) {
            return 'parent';
        }

        return 'inactive';
    }

    /**
     * Check whether a given theme is the active theme.
     *
     * @param WP_Theme $theme Theme to check.
     *
     * @return bool Whether the provided theme is the active theme.
     */
    protected function is_active_theme( $theme ) {
        return $theme->get_stylesheet_directory() === get_stylesheet_directory();
    }

    /**
     * Check whether a given theme is the active theme parent.
     *
     * @param WP_Theme $theme Theme to check.
     *
     * @return bool Whether the provided theme is the active theme.
     */
    protected function is_active_parent_theme( $theme ) {
        return $theme->get_stylesheet_directory() === get_template_directory();
    }

    /**
     * Get the available update info.
     *
     * @return mixed Available update info.
     */
    protected function get_update_info() {
        return get_site_transient( 'update_themes' );
    }
}