/**
 * Broken Links Redirector component.
 */
import { useState, useEffect } from '@wordpress/element';
import { 
    ArrowPathIcon, 
    ExclamationCircleIcon, 
    PlusIcon, 
    TrashIcon, 
    HomeIcon, 
    LinkIcon,
    DocumentDuplicateIcon
} from '@heroicons/react/24/outline';

/**
 * Internal dependencies.
 */
import Layout from '../layout/Layout';
import { 
    fetchRedirectRules, 
    addRedirectRule, 
    deleteRedirectRule,
    fetchRedirectSettings,
    updateRedirectSettings,
    fetch404Logs,
    clear404Logs,
    fetchSuggestedRedirects
} from '../../api/broken-links-redirector';
import { showPromiseToast, showToast } from '../../utils';
import toast from 'react-hot-toast';
import RedirectRulesTab from './redirector/RedirectRulesTab';
import RedirectSettingsTab from './redirector/RedirectSettingsTab';
import LogsTab from './redirector/LogsTab';
import SuggestionsTab from './redirector/SuggestionsTab';

const BrokenLinksRedirector = () => {
    const [activeTab, setActiveTab] = useState('rules');
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);
    
    // Data states
    const [redirectRules, setRedirectRules] = useState([]);
    const [redirectSettings, setRedirectSettings] = useState({
        redirect_mode: 'custom_404',
        custom_url: '',
        auto_redirect: false,
        log_404s: true,
        max_logs: 100,
        exclude_patterns: []
    });
    const [logs, setLogs] = useState([]);
    const [suggestions, setSuggestions] = useState([]);
    
    // Load data based on active tab
    useEffect(() => {
        loadData();
    }, [activeTab]);
    
    // Load data for the current tab
    const loadData = async () => {
        setLoading(true);
        setError(null);
        
        try {
            // Load data based on active tab
            switch (activeTab) {
                case 'rules':
                    await loadRedirectRules();
                    break;
                case 'settings':
                    await loadRedirectSettings();
                    break;
                case 'logs':
                    await loadLogs();
                    break;
                case 'suggestions':
                    await loadSuggestions();
                    break;
            }
        } catch (err) {
            console.error(`Error loading ${activeTab} data:`, err);
            setError(`Failed to load ${activeTab} data. Please try again.`);
        } finally {
            setLoading(false);
        }
    };
    
    // Load redirect rules
    const loadRedirectRules = async () => {
        const rules = await fetchRedirectRules();
        setRedirectRules(rules);
    };
    
    // Load redirect settings
    const loadRedirectSettings = async () => {
        try {
            const settings = await fetchRedirectSettings();
            if (settings) {
                setRedirectSettings(settings);
            }
        } catch (err) {
            console.error('Error loading redirect settings:', err);
            setError('Failed to load settings. Please check your connection and try again.');
        }
    };
    
    // Load 404 logs
    const loadLogs = async () => {
        try {
            setError(null);
            const logsData = await fetch404Logs();
            
            // Ensure we have valid logs data
            if (Array.isArray(logsData)) {
                setLogs(logsData);
            } else {
                // If we get invalid data, set to empty array
                setLogs([]);
            }
        } catch (err) {
            console.error('Error loading 404 logs:', err);
            setError('Failed to load 404 logs. Please try again.');
            setLogs([]);
        }
    };
    
    // Load suggested redirects
    const loadSuggestions = async () => {
        const suggestionsData = await fetchSuggestedRedirects();
        setSuggestions(suggestionsData);
    };
    
    // Handle adding a redirect rule
    const handleAddRule = async (fromUrl, toUrl) => {
        try {
            await showPromiseToast(
                addRedirectRule(fromUrl, toUrl),
                'Adding redirect rule...',
                'Redirect rule added successfully!',
                'Failed to add redirect rule.'
            );
            
            // Reload rules
            await loadRedirectRules();
            return true;
        } catch (err) {
            console.error('Error adding redirect rule:', err);
            return false;
        }
    };
    
    // Handle deleting a redirect rule
    const handleDeleteRule = async (fromUrl) => {
        try {
            await showPromiseToast(
                deleteRedirectRule(fromUrl),
                'Deleting redirect rule...',
                'Redirect rule deleted successfully!',
                'Failed to delete redirect rule.'
            );
            
            // Reload rules
            await loadRedirectRules();
            return true;
        } catch (err) {
            console.error('Error deleting redirect rule:', err);
            return false;
        }
    };
    
    // Handle updating redirect settings
    const handleUpdateSettings = async (settings) => {
        try {
            setError(null);
            setLoading(true);
            
            // Make the API call
            const response = await updateRedirectSettings(settings);
            
            // Handle the response
            if (response && response.success) {
                // Update local state with the new settings
                if (response.settings) {
                    setRedirectSettings(response.settings);
                } else {
                    // If response doesn't include settings, reload them
                    await loadRedirectSettings();
                }
                
                // Show success message
                showToast('Settings updated successfully!', 'success');
                return true;
            } else {
                showToast('Failed to update settings.', 'error');
                return false;
            }
        } catch (err) {
            console.error('Error updating settings:', err);
            setError('Failed to update settings. Please try again.');
            showToast('Failed to update settings.', 'error');
            return false;
        } finally {
            setLoading(false);
        }
    };
    
    // Handle clearing 404 logs
    const handleClearLogs = async () => {
        if (!window.confirm('Are you sure you want to clear all 404 logs? This action cannot be undone.')) {
            return false;
        }
        
        try {
            setError(null);
            setLoading(true);
            
            // Make the API call with error handling
            try {
                const response = await clear404Logs();
                
                if (response && response.success) {
                    showToast('Logs cleared successfully!', 'success');
                    
                    // Set logs to empty array immediately
                    setLogs([]);
                    return true;
                } else {
                    showToast('Failed to clear logs.', 'error');
                    return false;
                }
            } catch (apiError) {
                console.error('API error clearing logs:', apiError);
                showToast('Failed to clear logs: ' + (apiError.message || 'Unknown error'), 'error');
                return false;
            }
        } catch (err) {
            console.error('Error clearing logs:', err);
            setError('Failed to clear logs. Please try again.');
            return false;
        } finally {
            setLoading(false);
        }
    };
    
    // Handle applying a suggested redirect
    const handleApplySuggestion = async (fromUrl, toUrl) => {
        return await handleAddRule(fromUrl, toUrl);
    };
    
    return (
        <Layout>
            <div className="bg-white rounded-lg shadow p-6">
                <div className="mb-6">
                    <h1 className="text-2xl font-bold text-gray-900">🔄 Auto-Redirect Broken Links</h1>
                    <p className="mt-1 text-gray-600">
                        Automatically detect and redirect 404 errors to improve user experience and SEO.
                    </p>
                </div>
                
                {error && (
                    <div className="mb-6 bg-red-50 border-l-4 border-red-400 p-4">
                        <div className="flex">
                            <div className="flex-shrink-0">
                                <ExclamationCircleIcon className="h-5 w-5 text-red-400" aria-hidden="true" />
                            </div>
                            <div className="ml-3">
                                <p className="text-sm text-red-700">{error}</p>
                            </div>
                        </div>
                    </div>
                )}
                
                {/* Tabs */}
                <div className="mb-6">
                    <div className="border-b border-gray-200">
                        <nav className="-mb-px flex space-x-8" aria-label="Tabs">
                            <button
                                onClick={() => setActiveTab('rules')}
                                className={`${
                                    activeTab === 'rules'
                                        ? 'border-blue-500 text-blue-600'
                                        : 'border-transparent text-gray-500 hover:text-gray-700 hover:border-gray-300'
                                } whitespace-nowrap py-4 px-1 border-b-2 font-medium text-sm flex items-center`}
                            >
                                <LinkIcon className="h-5 w-5 mr-2" />
                                Redirect Rules
                            </button>
                            <button
                                onClick={() => setActiveTab('settings')}
                                className={`${
                                    activeTab === 'settings'
                                        ? 'border-blue-500 text-blue-600'
                                        : 'border-transparent text-gray-500 hover:text-gray-700 hover:border-gray-300'
                                } whitespace-nowrap py-4 px-1 border-b-2 font-medium text-sm flex items-center`}
                            >
                                <HomeIcon className="h-5 w-5 mr-2" />
                                Settings
                            </button>
                            <button
                                onClick={() => setActiveTab('logs')}
                                className={`${
                                    activeTab === 'logs'
                                        ? 'border-blue-500 text-blue-600'
                                        : 'border-transparent text-gray-500 hover:text-gray-700 hover:border-gray-300'
                                } whitespace-nowrap py-4 px-1 border-b-2 font-medium text-sm flex items-center`}
                            >
                                <DocumentDuplicateIcon className="h-5 w-5 mr-2" />
                                404 Logs
                            </button>
                            <button
                                onClick={() => setActiveTab('suggestions')}
                                className={`${
                                    activeTab === 'suggestions'
                                        ? 'border-blue-500 text-blue-600'
                                        : 'border-transparent text-gray-500 hover:text-gray-700 hover:border-gray-300'
                                } whitespace-nowrap py-4 px-1 border-b-2 font-medium text-sm flex items-center`}
                            >
                                <PlusIcon className="h-5 w-5 mr-2" />
                                Suggestions
                            </button>
                        </nav>
                    </div>
                </div>
                
                {/* Refresh Button */}
                <div className="mb-4">
                    <button
                        onClick={loadData}
                        disabled={loading}
                        className="inline-flex items-center px-3 py-2 border border-gray-300 shadow-sm text-sm leading-4 font-medium rounded-md text-gray-700 bg-white hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500"
                    >
                        <ArrowPathIcon className={`-ml-0.5 mr-2 h-4 w-4 ${loading ? 'animate-spin' : ''}`} />
                        Refresh
                    </button>
                </div>
                
                {/* Tab Content */}
                {loading ? (
                    <div className="text-center py-12">
                        <div className="inline-block animate-spin rounded-full h-8 w-8 border-t-2 border-b-2 border-blue-500"></div>
                        <p className="mt-2 text-gray-600">Loading...</p>
                    </div>
                ) : (
                    <>
                        {activeTab === 'rules' && (
                            <RedirectRulesTab 
                                rules={redirectRules} 
                                onAddRule={handleAddRule} 
                                onDeleteRule={handleDeleteRule} 
                            />
                        )}
                        
                        {activeTab === 'settings' && (
                            <RedirectSettingsTab 
                                settings={redirectSettings} 
                                onUpdateSettings={handleUpdateSettings} 
                            />
                        )}
                        
                        {activeTab === 'logs' && (
                            <LogsTab 
                                logs={logs} 
                                onClearLogs={handleClearLogs} 
                                onCreateRule={handleAddRule} 
                            />
                        )}
                        
                        {activeTab === 'suggestions' && (
                            <SuggestionsTab 
                                suggestions={suggestions} 
                                onApplySuggestion={handleApplySuggestion} 
                            />
                        )}
                    </>
                )}
                
                <div className="mt-6 bg-blue-50 p-4 rounded-md">
                    <h3 className="text-sm font-medium text-blue-800">Why this matters:</h3>
                    <ul className="mt-2 text-sm text-blue-700 list-disc pl-5 space-y-1">
                        <li>Broken links can harm your site's SEO and user experience</li>
                        <li>Redirecting 404 errors to relevant content keeps visitors engaged</li>
                        <li>Monitoring 404 logs helps identify and fix navigation issues</li>
                        <li>Smart redirects preserve SEO value from inbound links</li>
                    </ul>
                </div>
            </div>
        </Layout>
    );
};

export default BrokenLinksRedirector;
