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

class AF_Translate_Analyzer {

    /**
     * Normalizes and restricts component structural types.
     */
    private static function clean_component_type( $type ) {
        $type = ( 'themes' === $type ) ? 'theme' : $type;
        $type = ( 'plugins' === $type ) ? 'plugin' : $type;
        return ( 'theme' === $type ) ? 'theme' : 'plugin';
    }

    /**
     * Validates that a file path lives strictly within authorized WordPress system frames.
     * Case-insensitive check protects against local server case-mismatches.
     */
    /**
     * Validates that a file path lives strictly within authorized WordPress system frames.
     * Uses realpath() to permanently neutralize directory traversal attacks (../).
     */
    private static function verify_path_containment( $file_path ) {
        if ( empty( $file_path ) ) {
            return false;
        }

        // 1. Resolve canonical path to kill any directory traversal hacks (../)
        $real_path = realpath( $file_path );
        if ( false === $real_path ) {
            return false; // File or directory doesn't exist on disk
        }

        $normalized_path = wp_normalize_path( $real_path );
        $upload_dir      = wp_upload_dir();
        
        $allowed_root_matrices = array(
            wp_normalize_path( WP_LANG_DIR ),
            wp_normalize_path( WP_PLUGIN_DIR ),
            wp_normalize_path( get_theme_root() ),
            wp_normalize_path( $upload_dir['basedir'] )
        );

        // 2. Strict prefix validation against real, resolved paths
        foreach ( $allowed_root_matrices as $root_prefix ) {
            if ( stripos( $normalized_path, $root_prefix ) === 0 ) {
                return true;
            }
        }

        return false;
    }

    /**
     * Resolves absolute operating system path matrices for local localization setups.
     */
    public static function locate_translation_dirs( $slug, $type ) {
        $slug = sanitize_key( $slug );
        $type = self::clean_component_type( $type );
        
        $base = ( 'theme' === $type ) 
            ? wp_normalize_path( get_theme_root() . '/' . $slug ) 
            : wp_normalize_path( WP_PLUGIN_DIR . '/' . $slug );
        
        $lang_dir   = wp_normalize_path( WP_LANG_DIR );
        $upload_dir = wp_upload_dir();
        $sub_folder = ( 'plugin' === $type ) ? 'plugins' : 'themes';
        
        return array(
            'author' => $base . '/languages',
            'system' => $lang_dir . '/' . $type . 's',
            'custom' => wp_normalize_path( trailingslashit( $upload_dir['basedir'] ) . "af-translate/{$sub_folder}" )
        );
    }

    /**
     * Aggregates configuration files across disk architectures safely.
     */
    public static function get_component_summary( $slug, $type ) {
        if ( ! current_user_can( 'manage_options' ) ) {
            return array(
                'text_domain'   => sanitize_key( $slug ),
                'pot_exists'    => false,
                'pot_file'      => '', 
                'po_count'      => 0,
                'po_collection' => array()
            );
        }

        $slug = sanitize_key( $slug );
        $type = self::clean_component_type( $type );
        
        $dirs      = self::locate_translation_dirs( $slug, $type );
        $pot_files = array();
        $po_files  = array();

        foreach ( $dirs as $key => $dir ) {
            if ( is_dir( $dir ) && self::verify_path_containment( $dir ) ) {
                
                $found_pots = glob( trailingslashit( $dir ) . "*.pot" );
                if ( ! empty( $found_pots ) && is_array( $found_pots ) ) {
                    foreach ( $found_pots as $pot ) {
                        $pot_name = basename( $pot );
                        if ( 'system' !== $key || $pot_name === "{$slug}.pot" ) {
                            $pot_files[] = wp_normalize_path( $pot );
                        }
                    }
                }

                $found_pos = glob( trailingslashit( $dir ) . "*.po" );
                if ( ! empty( $found_pos ) && is_array( $found_pos ) ) {
                    foreach ( $found_pos as $po ) {
                        $filename = basename( $po );

                        if ( 'author' === $key ) {
                            $po_files[] = wp_normalize_path( $po );
                        } else {
                            if ( stripos( $filename, "{$slug}-" ) === 0 ) {
                                $po_files[] = wp_normalize_path( $po );
                            }
                        }
                    }
                }
            }
        }

        $pot_files = array_unique( array_filter( $pot_files ) );
        $po_files  = array_unique( array_filter( $po_files ) );

        $primary_pot = '';
        if ( ! empty( $pot_files ) ) {
            foreach ( $pot_files as $pot ) {
                if ( basename( $pot ) === "{$slug}.pot" ) {
                    $primary_pot = $pot;
                    break;
                }
            }
            if ( empty( $primary_pot ) ) {
                $reset_pot = reset( $pot_files );
                if ( is_string( $reset_pot ) ) {
                    $primary_pot = $reset_pot;
                }
            }
        }

        return array(
            'text_domain'   => $slug,
            'pot_exists'    => ! empty( $primary_pot ),
            'pot_file'      => $primary_pot, 
            'po_count'      => count( $po_files ),
            'po_collection' => $po_files
        );
    }

    /**
     * Reads, tokenizes, and aggregates real completion matrices using native WP Core POMO classes.
     */
    public static function analyze_po_file( $file_path ) {
        $metrics = array(
            'total'      => 0,
            'translated' => 0,
            'percentage' => 0
        );
    
        // 1. Security & Containment Guards
        if ( ! current_user_can( 'manage_options' ) || ! self::verify_path_containment( $file_path ) ) {
            return $metrics;
        }
    
        if ( ! file_exists( $file_path ) || ! is_readable( $file_path ) ) {
            return $metrics;
        }
    
        // 2. Include Native WordPress POMO library components if missing
        if ( ! class_exists( 'PO' ) ) {
            require_once ABSPATH . 'wp-includes/pomo/po.php';
        }
    
        // 3. Initialize core parser and import the stream
        $po_parser = new PO();
        if ( false === $po_parser->import_from_file( $file_path ) ) {
            return $metrics;
        }
    
        // 4. If the file has entries, iterate through the Core Translation_Entry objects
        if ( ! empty( $po_parser->entries ) && is_array( $po_parser->entries ) ) {
            foreach ( $po_parser->entries as $entry ) {
                
                // Core maps file meta headers to an empty msgid string. Skip cleanly.
                if ( '' === $entry->singular ) {
                    continue;
                }
    
                $metrics['total']++;
    
                // 5. FIXED: Safely loop inside the inner translation collection array
                if ( ! empty( $entry->translations ) && is_array( $entry->translations ) ) {
                    $is_valid_translation = false;
                    
                    foreach ( $entry->translations as $string_variant ) {
                        if ( '' !== trim( (string) $string_variant ) ) {
                            $is_valid_translation = true;
                            break; // Stop looking if at least one variant configuration is populated
                        }
                    }
                    
                    if ( $is_valid_translation ) {
                        $metrics['translated']++;
                    }
                }
            }
        }
    
        // 6. Compute completion metrics
        if ( $metrics['total'] > 0 ) {
            $metrics['percentage'] = (int) round( ( $metrics['translated'] / $metrics['total'] ) * 100 );
        }
    
        return $metrics;
    }
}