"""
Integration tests for site page generation
"""

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from src.database.models import Base, SiteDeployment, SitePage
from src.database.repositories import SiteDeploymentRepository, SitePageRepository
from src.templating.service import TemplateService
from src.generation.site_page_generator import generate_site_pages


@pytest.fixture
def test_db():
    """Create a test database"""
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    yield session
    session.close()


@pytest.fixture
def site_repo(test_db):
    return SiteDeploymentRepository(test_db)


@pytest.fixture
def page_repo(test_db):
    return SitePageRepository(test_db)


@pytest.fixture
def template_service():
    return TemplateService()


@pytest.fixture
def sample_site(site_repo):
    """Create a sample site for testing"""
    return site_repo.create(
        site_name="integration-test-site",
        storage_zone_id=999,
        storage_zone_name="test-storage",
        storage_zone_password="test-password",
        storage_zone_region="DE",
        pull_zone_id=888,
        pull_zone_bcdn_hostname="integration-test.b-cdn.net",
        custom_hostname=None
    )


class TestSitePageIntegration:
    """Integration tests for site page generation flow"""
    
    def test_full_page_generation_flow(self, sample_site, page_repo, template_service):
        """Test complete flow of generating pages for a site"""
        pages = generate_site_pages(sample_site, "basic", page_repo, template_service)
        
        assert len(pages) == 3
        
        stored_pages = page_repo.get_by_site(sample_site.id)
        assert len(stored_pages) == 3
        
        page_types = {p.page_type for p in stored_pages}
        assert page_types == {"about", "contact", "privacy"}
    
    def test_pages_use_correct_template(self, sample_site, page_repo, template_service):
        """Test that pages are formatted with correct template"""
        generate_site_pages(sample_site, "modern", page_repo, template_service)
        
        about_page = page_repo.get_by_site_and_type(sample_site.id, "about")
        assert about_page is not None
        assert "<html" in about_page.content.lower()
        assert "About Us" in about_page.content
    
    def test_multiple_templates(self, site_repo, page_repo, template_service):
        """Test page generation with different templates"""
        templates = ["basic", "modern", "classic"]
        
        for template_name in templates:
            site = site_repo.create(
                site_name=f"test-{template_name}",
                storage_zone_id=100 + templates.index(template_name),
                storage_zone_name=f"storage-{template_name}",
                storage_zone_password="password",
                storage_zone_region="DE",
                pull_zone_id=200 + templates.index(template_name),
                pull_zone_bcdn_hostname=f"{template_name}.b-cdn.net"
            )
            
            pages = generate_site_pages(site, template_name, page_repo, template_service)
            assert len(pages) == 3
            
            for page in pages:
                assert "<html" in page.content.lower()
    
    def test_pages_not_duplicated(self, sample_site, page_repo, template_service):
        """Test that running generation twice doesn't duplicate pages"""
        generate_site_pages(sample_site, "basic", page_repo, template_service)
        
        generate_site_pages(sample_site, "basic", page_repo, template_service)
        
        pages = page_repo.get_by_site(sample_site.id)
        assert len(pages) == 3
    
    def test_page_content_structure(self, sample_site, page_repo, template_service):
        """Test that generated pages have proper HTML structure"""
        generate_site_pages(sample_site, "basic", page_repo, template_service)
        
        for page_type in ["about", "contact", "privacy"]:
            page = page_repo.get_by_site_and_type(sample_site.id, page_type)
            assert page is not None
            
            content = page.content
            assert "<!DOCTYPE html>" in content or "<html" in content.lower()
            assert "<head>" in content.lower()
            assert "<body>" in content.lower()
            assert "<nav>" in content.lower()
    
    def test_custom_hostname_vs_bcdn(self, site_repo, page_repo, template_service):
        """Test page generation for sites with and without custom hostnames"""
        site_custom = site_repo.create(
            site_name="custom-hostname-site",
            storage_zone_id=111,
            storage_zone_name="custom-storage",
            storage_zone_password="password",
            storage_zone_region="DE",
            pull_zone_id=222,
            pull_zone_bcdn_hostname="custom.b-cdn.net",
            custom_hostname="www.custom-domain.com"
        )
        
        site_bcdn = site_repo.create(
            site_name="bcdn-only-site",
            storage_zone_id=333,
            storage_zone_name="bcdn-storage",
            storage_zone_password="password",
            storage_zone_region="DE",
            pull_zone_id=444,
            pull_zone_bcdn_hostname="bcdn-only.b-cdn.net",
            custom_hostname=None
        )
        
        pages_custom = generate_site_pages(site_custom, "basic", page_repo, template_service)
        pages_bcdn = generate_site_pages(site_bcdn, "basic", page_repo, template_service)
        
        assert len(pages_custom) == 3
        assert len(pages_bcdn) == 3
        
        assert all(p.content for p in pages_custom)
        assert all(p.content for p in pages_bcdn)