// export function getLanguageValueFromSubdomain(host: string | null): string | null {
//     if (!host) {
//         return null;
//     }

//     const parts = host.split('.');
//     for (const part of parts) {
//         if (part === 'ar' || part.startsWith('ar-')) {
//             return 'ar';
//         }
//     }
//     return 'en';
// }

interface ParsedHost {
    hostname: string;
    subdomain: string;
    baseDomain: string;
}

function parseHost(host?: string | null): ParsedHost {
    let activeHost = host || (typeof window !== 'undefined' ? window.location.hostname : '');

    activeHost = activeHost.split(':')[0];

    const parts = activeHost.split('.');

    if (parts.length === 1) {
        return { hostname: activeHost, subdomain: '', baseDomain: activeHost };
    }

    if (activeHost.includes('localhost')) {
        return {
            hostname: activeHost,
            subdomain: parts.slice(0, -1).join('.'),
            baseDomain: 'localhost'
        };
    }

    if (parts.length === 2) {
        return { hostname: activeHost, subdomain: '', baseDomain: activeHost };
    }

    const baseDomain = parts.slice(-2).join('.');
    const subdomain = parts.slice(0, -2).join('.');

    return { hostname: activeHost, subdomain, baseDomain };
}

export const getValidSubdomain = (host?: string | null): string | null => {
    const { subdomain } = parseHost(host);
    return subdomain || null;
};

export function getSubdomain(host?: string | null): string | null {
    const subdomain = getValidSubdomain(host);
    if (!subdomain) return null;
    return subdomain.startsWith('ar-') ? (subdomain.split('-')[1] || null) : subdomain;
}

export function getLanguageValueFromSubdomain(host: string | null): 'en' | 'ar' {
    const { subdomain } = parseHost(host);
    const parts = subdomain.split('-');

    if (parts.includes('ar')) return 'ar';
    return 'en';
}

// 1. Correctly detect the active country from hostname
export function getCountrySubDomainFromHostname(host: string | null | undefined): 'my' | 'ae' {
    const { subdomain } = parseHost(host);
    const parts = subdomain.split('-');

    if (parts.includes('my') || subdomain.includes('dytcmy') || subdomain.endsWith('my')) {
        return 'my';
    }
    return 'ae';
}

// 2. Build the correct subdomain prefixes for redirection
function buildSubdomainPrefix(country: 'my' | 'ae', lang: string): string {
    if (country === 'my') {
        return lang === 'ar' ? 'dytcmy-ar.' : 'dytcmy.';
    }
    // UAE / Default country
    return lang === 'ar' ? 'dytc-ar.' : 'dytc.';
}
export function getLanguageDirectionFromSubdomain(host: string | null): 'rtl' | 'ltr' {
    const lang = getLanguageValueFromSubdomain(host);
    return lang === 'ar' ? 'rtl' : 'ltr';
}

export function getLanguageDirectionChangeFromSubdomain(lang: string): 'right' | 'left' {
    return lang === 'en' ? 'right' : 'left';
}

export function getLanguageDirectionLeftTorightChangeFromSubdomain(lang: string): 'right' | 'left' {
    return lang === 'ar' ? 'right' : 'left';
}

// function buildSubdomainPrefix(country: 'my' | 'ae', lang: string): string {
//     if (country === 'my') {
//         return lang === 'ar' ? 'my-ar.' : 'my.';
//     }
//     return lang !== 'en' ? `${lang}.` : '';
// }

export function getLanguageRedirectUrl(newLang: string, hostname: string): string {
    const { baseDomain } = parseHost(hostname);
    const configuredBase = process.env.NEXT_PUBLIC_LANGUAGE_BASE_URL || baseDomain;
    const country = getCountrySubDomainFromHostname(hostname);

    return `${buildSubdomainPrefix(country, newLang)}${configuredBase}`;
}

export function getCountryRedirectUrl(newCountry: string, hostname: string): string {
    const { baseDomain } = parseHost(hostname);
    const configuredBase = process.env.NEXT_PUBLIC_LANGUAGE_BASE_URL || baseDomain;
    const currentLang = getLanguageValueFromSubdomain(hostname);

    return `${buildSubdomainPrefix(newCountry as 'my' | 'ae', currentLang)}${configuredBase}`;
}

function executeRedirect(redirectHost: string) {
    if (typeof window === "undefined") return;

    const { protocol, pathname, search } = window.location;

    // Detect port from current window location, or default to 3000 if testing on localhost
    let port = window.location.port;
    if (!port && redirectHost.includes("localhost")) {
        port = "3000";
    }

    const portSuffix = port ? `:${port}` : "";

    window.location.href = `${protocol}//${redirectHost}${portSuffix}${pathname}${search}`;
}
// function executeRedirect(redirectHost: string) {
//     if (typeof window === 'undefined') return;
//     const { protocol, pathname, search } = window.location;
//     window.location.href = `${protocol}//${redirectHost}${pathname}${search}`;
// }

export function redirectToLanguage(newLang: string) {
    if (typeof window === 'undefined') return;
    executeRedirect(getLanguageRedirectUrl(newLang, window.location.hostname));
}

export function redirectToCountry(newCountry: string) {
    if (typeof window === 'undefined') return;
    executeRedirect(getCountryRedirectUrl(newCountry, window.location.hostname));
}

export const COUNTRY_CONFIG = {
    ae: {
        language: "en",
        country: "ae",
    },
    my: {
        language: "en",
        country: "my",
    },
};