#!/bin/bash

set -e
set -o pipefail

# Source common utilities
source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/wild-common.sh"

# Initialize Wild-Cloud environment
init_wild_env

# Parse arguments
SKIP_INSTALL=false

while [[ $# -gt 0 ]]; do
    case $1 in
        --skip-install)
            SKIP_INSTALL=true
            shift
            ;;
        -h|--help)
            echo "Usage: $0 [options]"
            echo ""
            echo "Install Kubernetes cluster services (Phase 4)."
            echo ""
            echo "Options:"
            echo "  --skip-install      Generate service configs but skip installation"
            echo "  -h, --help          Show this help message"
            echo ""
            echo "This script will:"
            echo "  - Configure DNS and SSL certificate settings"
            echo "  - Configure storage settings (NFS, Docker registry)"
            echo "  - Generate cluster service configurations"
            echo "  - Install core services (MetalLB, Traefik, cert-manager, etc.)"
            echo ""
            echo "Prerequisites:"
            echo "  - Run 'wild-setup-scaffold' to initialize the cloud"
            echo "  - Run 'wild-setup-cluster' to set up cluster infrastructure"
            echo "  - Kubernetes cluster must be running and kubectl configured"
            exit 0
            ;;
        -*)
            echo "Unknown option $1"
            echo "Usage: $0 [options]"
            echo "Use --help for full usage information"
            exit 1
            ;;
        *)
            echo "Unexpected argument: $1"
            echo "Usage: $0 [options]"
            echo "Use --help for full usage information"
            exit 1
            ;;
    esac
done

# Check if we're in a wild-cloud directory
check_wild_directory

# Check basic configuration
check_basic_config

# Check cluster configuration
if [ -z "$(get_current_config "cluster.name")" ]; then
    print_error "Cluster configuration is missing"
    print_info "Run 'wild-setup-cluster' first to configure cluster settings"
    exit 1
fi

print_header "Wild-Cloud Services Setup"
print_info "Installing Kubernetes cluster services (Phase 4)"
echo ""

# =============================================================================
# Cluster Services Installation
# =============================================================================

print_header "Cluster Services Installation"

# Configure DNS and certificates
if [ -z "$(get_current_config "cluster.certManager.cloudflare.domain")" ]; then
    print_header "DNS and Certificate Configuration"
    echo "For automatic SSL certificates and DNS management, we use Cloudflare."
    echo ""

    base_domain=$(get_current_config "cloud.baseDomain")
    domain=$(get_current_config "cloud.domain")
    
    echo "Is your domain '${base_domain}' registered and managed through Cloudflare? (y/n)"
    read -r use_cloudflare

    if [[ "${use_cloudflare}" =~ ^[Yy]$ ]]; then
        wild-config-set "cluster.certManager.cloudflare.domain" "${domain}"
        
        current_cf_token=$(get_current_secret "cloudflare.token")
        if [ -z "${current_cf_token}" ]; then
            echo ""
            print_info "You'll need a Cloudflare API token with the following permissions:"
            echo "  - Zone:Zone:Read"
            echo "  - Zone:DNS:Edit"
            echo "  - Include:All zones"
            echo ""
            echo "Create one at: https://dash.cloudflare.com/profile/api-tokens"
            echo ""
        fi
        
        cf_token=$(prompt_with_default "Cloudflare API token" "" "${current_cf_token}")
        wild-secret-set "cloudflare.token" "${cf_token}"
    else
        print_warning "You'll need to configure DNS and SSL certificates manually."
        print_info "Consider transferring your domain to Cloudflare for easier management."
    fi
    
    print_success "DNS and certificate configuration completed"
    echo ""
fi

# Configure core network settings
print_header "Network Configuration"

# Get basic domain configuration (should already be set from earlier setup)
domain=$(get_current_config "cloud.domain")
internal_domain=$(get_current_config "cloud.internalDomain")
operator_email=$(get_current_config "operator.email")

if [ -z "$domain" ] || [ -z "$internal_domain" ] || [ -z "$operator_email" ]; then
    print_error "Basic domain and operator configuration missing"
    print_info "Please run 'wild-setup-scaffold' first to configure basic settings"
    exit 1
fi

# Load balancer IP configuration
current_lb_ip=$(get_current_config "cluster.loadBalancerIp")
if [ -z "$current_lb_ip" ] || [ "$current_lb_ip" = "null" ]; then
    lb_ip=$(prompt_with_default "Load balancer IP address" "" "${current_lb_ip}")
    wild-config-set "cluster.loadBalancerIp" "${lb_ip}"
fi

# IP address pool for MetalLB
current_ip_pool=$(get_current_config "cluster.ipAddressPool")
if [ -z "$current_ip_pool" ] || [ "$current_ip_pool" = "null" ]; then
    current_lb_ip=$(get_current_config "cluster.loadBalancerIp")
    ip_pool=$(prompt_with_default "IP address pool for load balancer (range)" "${current_lb_ip}-${current_lb_ip}" "${current_ip_pool}")
    wild-config-set "cluster.ipAddressPool" "${ip_pool}"
fi

# External DNS resolver for CoreDNS
current_dns_resolver=$(get_current_config "cloud.dns.externalResolver")
if [ -z "$current_dns_resolver" ] || [ "$current_dns_resolver" = "null" ]; then
    dns_resolver=$(prompt_with_default "External DNS resolver" "1.1.1.1" "${current_dns_resolver}")
    wild-config-set "cloud.dns.externalResolver" "${dns_resolver}"
fi

# ExternalDNS owner ID (unique identifier for DNS records)
current_owner_id=$(get_current_config "cluster.externalDns.ownerId")
if [ -z "$current_owner_id" ] || [ "$current_owner_id" = "null" ]; then
    cluster_name=$(get_current_config "cluster.name")
    default_owner_id="${cluster_name:-wild-cloud}-$(date +%s)"
    owner_id=$(prompt_with_default "ExternalDNS owner ID (unique identifier)" "${default_owner_id}" "${current_owner_id}")
    wild-config-set "cluster.externalDns.ownerId" "${owner_id}"
fi

print_success "Network configuration completed"
echo ""

# Configure storage settings  
print_header "Storage Configuration"

dns_ip=$(get_current_config "cloud.dns.ip")
internal_domain=$(get_current_config "cloud.internalDomain")

# NFS settings
current_nfs_host=$(get_current_config "cloud.nfs.host")
if [ -z "$current_nfs_host" ] || [ "$current_nfs_host" = "null" ]; then
    nfs_host=$(prompt_with_default "NFS server host" "${dns_ip}" "${current_nfs_host}")
    wild-config-set "cloud.nfs.host" "${nfs_host}"
fi

current_media_path=$(get_current_config "cloud.nfs.mediaPath")
if [ -z "$current_media_path" ] || [ "$current_media_path" = "null" ]; then
    media_path=$(prompt_with_default "NFS media path" "/mnt/storage/media" "${current_media_path}")
    wild-config-set "cloud.nfs.mediaPath" "${media_path}"
fi

current_storage_capacity=$(get_current_config "cloud.nfs.storageCapacity")
if [ -z "$current_storage_capacity" ] || [ "$current_storage_capacity" = "null" ]; then
    storage_capacity=$(prompt_with_default "Storage capacity for NFS PV" "1Ti" "${current_storage_capacity}")
    wild-config-set "cloud.nfs.storageCapacity" "${storage_capacity}"
fi

# Docker Registry settings
current_registry_host=$(get_current_config "cloud.dockerRegistryHost")
if [ -z "$current_registry_host" ] || [ "$current_registry_host" = "null" ]; then
    registry_host=$(prompt_with_default "Docker registry hostname" "registry.${internal_domain}" "${current_registry_host}")
    wild-config-set "cloud.dockerRegistryHost" "${registry_host}"
fi

current_registry_storage=$(get_current_config "cluster.dockerRegistry.storage")
if [ -z "$current_registry_storage" ] || [ "$current_registry_storage" = "null" ]; then
    registry_storage=$(prompt_with_default "Docker registry storage size" "10Gi" "${current_registry_storage}")
    wild-config-set "cluster.dockerRegistry.storage" "${registry_storage}"
fi

print_success "Storage configuration completed"
echo ""

print_info "This phase prepares and installs core cluster services (MetalLB, Traefik, cert-manager, etc.)"
print_warning "Make sure your cluster is running and kubectl is configured!"

# Generate cluster services setup files
print_info "Generating cluster services setup files..."
wild-cluster-services-generate --force

if [ "${SKIP_INSTALL}" = false ]; then
    read -p "Do you want to install cluster services now? (y/N): " -r install_services
    
    if [[ $install_services =~ ^[Yy]$ ]]; then
        print_info "Installing cluster services..."
        wild-cluster-services-up
        SERVICES_INSTALLED=true
    else
        print_info "Skipping cluster services installation"
        print_info "You can install them later with: wild-cluster-services-up"
        SKIP_INSTALL=true
    fi
else
    print_info "Skipping cluster services installation (--skip-install specified)"
    print_info "You can install them later with: wild-cluster-services-up"
fi

if [ "${SKIP_INSTALL}" = false ] && [ "${SERVICES_INSTALLED:-false}" = true ]; then
    print_success "Completed: Cluster services installation"
else
    print_success "Completed: Cluster services configuration generated"
fi
echo ""

# =============================================================================
# COMPLETION
# =============================================================================

print_header "Wild-Cloud Services Setup Complete!"

print_success "Cluster services setup completed!"
echo ""

print_info "Configuration files:"
echo "  - ${WC_HOME}/config.yaml"
echo "  - ${WC_HOME}/secrets.yaml"

if [ -d "${WC_HOME}/setup/cluster" ]; then
    echo ""
    print_info "Generated service configurations:"
    echo "  - ${WC_HOME}/setup/cluster/"
fi

echo ""
if [ "${SKIP_INSTALL}" = false ] && [ "${SERVICES_INSTALLED:-false}" = true ]; then
    print_info "Cluster services have been installed!"
    echo ""
    
    if command -v kubectl >/dev/null 2>&1; then
        INTERNAL_DOMAIN=$(wild-config cloud.internalDomain 2>/dev/null || echo "your-internal-domain")
        echo "Next steps:"
        echo "  1. Access the dashboard at: https://dashboard.${INTERNAL_DOMAIN}"
        echo "  2. Get the dashboard token with: ./bin/dashboard-token"
        echo ""
        echo "To verify components, run:"
        echo "  - kubectl get pods -n cert-manager"
        echo "  - kubectl get pods -n externaldns"
        echo "  - kubectl get pods -n kubernetes-dashboard"
        echo "  - kubectl get clusterissuers"
    else
        echo "Next steps:"
        echo "  1. Verify your cluster services are running"
        echo "  2. Configure kubectl if not already done"
        echo "  3. Access your services via the configured ingress"
    fi
else
    echo "Next steps:"
    echo "  1. Ensure your cluster is running and kubectl is configured"
    echo "  2. Install services with: wild-cluster-services-up"
    echo "  3. Verify components are running correctly"
fi

print_success "Wild-Cloud setup completed!"