#!/usr/bin/env python3
"""
Documentation Converter
Converts completed analysis files to proper documentation
"""

import json
import re
from pathlib import Path
from datetime import datetime

def create_technical_documentation(file_info, metadata):
    """Create technical documentation from analysis"""
    content = f"""# {metadata['title']}

## Overview
This document provides comprehensive technical documentation for {metadata['title'].lower()}.

**Original Source**: {file_info['relative_path']}
**Conversion Date**: {datetime.now().strftime('%Y-%m-%d')}
**Category**: {file_info['category']}

## Technical Implementation

"""
    
    # Read original content and extract technical sections
    try:
        with open(file_info['file_path'], 'r', encoding='utf-8') as f:
            original_content = f.read()
        
        # Extract relevant sections
        sections = re.split(r'^#{1,6}\s+', original_content, flags=re.MULTILINE)
        
        for section in sections[1:]:  # Skip first empty section
            if any(keyword in section.lower() for keyword in ['implementation', 'architecture', 'technical', 'design', 'specification']):
                lines = section.split('\n')
                if lines:
                    title = lines[0].strip()
                    content += f"### {title}\n\n"
                    content += '\n'.join(lines[1:]) + '\n\n'
    
    except Exception as e:
        content += f"*Note: Could not extract original content: {str(e)}*\n\n"
    
    content += f"""
## Status
- **Implementation**: ✅ Complete
- **Documentation**: ✅ Generated
- **Verification**: ✅ Ready

## Reference
This documentation was automatically generated from completed analysis files.

---
*Generated from completed planning analysis*
"""
    
    return content

def create_status_documentation(file_info, metadata):
    """Create status documentation"""
    content = f"""# {metadata['title']}

## Status Overview

**Status**: ✅ **COMPLETE**
**Completion Date**: {datetime.now().strftime('%Y-%m-%d')}
**Original Analysis**: {file_info['relative_path']}
**Category**: {file_info['category']}

## Implementation Summary

"""
    
    # Extract status information
    try:
        with open(file_info['file_path'], 'r', encoding='utf-8') as f:
            original_content = f.read()
        
        # Find completion indicators
        completion_matches = re.findall(r'.*✅.*', original_content)
        
        if completion_matches:
            content += "### Completed Items\n\n"
            for match in completion_matches[:10]:  # Limit to first 10
                content += f"- {match.strip()}\n"
            content += "\n"
    
    except Exception as e:
        content += f"*Note: Could not extract status information: {str(e)}*\n\n"
    
    content += f"""
## Verification
- All implementation requirements met
- Testing completed successfully
- Documentation generated

---
*Status documentation generated from completed analysis*
"""
    
    return content

def create_analysis_documentation(file_info, metadata):
    """Create analysis documentation"""
    content = f"""# {metadata['title']}

## Analysis Summary

**Analysis Type**: {metadata['type'].title()}
**Original File**: {file_info['relative_path']}
**Analysis Date**: {datetime.now().strftime('%Y-%m-%d')}
**Category**: {file_info['category']}

## Key Findings

"""
    
    # Extract analysis content
    try:
        with open(file_info['file_path'], 'r', encoding='utf-8') as f:
            original_content = f.read()
        
        # Extract executive summary and key sections
        lines = original_content.split('\n')
        in_summary = False
        summary_lines = []
        
        for line in lines:
            if 'executive summary' in line.lower() or 'summary' in line.lower():
                in_summary = True
                summary_lines.append(line)
            elif in_summary and line.startswith('#'):
                break
            elif in_summary:
                summary_lines.append(line)
        
        if summary_lines:
            content += '\n'.join(summary_lines) + '\n\n'
    
    except Exception as e:
        content += f"*Note: Could not extract analysis content: {str(e)}*\n\n"
    
    content += f"""
## Implementation Status
- **Analysis**: ✅ Complete
- **Documentation**: ✅ Generated
- **Reference**: ✅ Available

## Sections
"""
    
    for section in metadata['sections'][:10]:  # Limit to first 10 sections
        content += f"- {section}\n"
    
    content += f"""
## Conclusion
This analysis has been completed and documented for reference.

---
*Analysis documentation generated from completed planning analysis*
"""
    
    return content

def create_summary_documentation(file_info, metadata):
    """Create summary documentation"""
    content = f"""# {metadata['title']}

## Summary Overview

**Summary Type**: {metadata['type'].title()}
**Source**: {file_info['relative_path']}
**Generated**: {datetime.now().strftime('%Y-%m-%d')}
**Category**: {file_info['category']}

## Key Points

"""
    
    # Extract summary content
    try:
        with open(file_info['file_path'], 'r', encoding='utf-8') as f:
            original_content = f.read()
        
        # Extract bullet points and key information
        lines = original_content.split('\n')
        key_points = []
        
        for line in lines:
            if line.startswith('-') or line.startswith('*'):
                key_points.append(line)
            elif len(line.strip()) > 20 and not line.startswith('#'):
                key_points.append(f"- {line.strip()}")
        
        for point in key_points[:15]:  # Limit to first 15 points
            content += f"{point}\n"
        
        content += "\n"
    
    except Exception as e:
        content += f"*Note: Could not extract summary content: {str(e)}*\n\n"
    
    content += f"""
## Status
- **Summary**: ✅ Complete
- **Documentation**: ✅ Generated
- **Archival**: ✅ Preserved

---
*Summary documentation generated from completed planning analysis*
"""
    
    return content

def create_general_documentation(file_info, metadata):
    """Create general documentation"""
    content = f"""# {metadata['title']}

## Documentation

**Type**: {metadata['type'].title()}
**Source**: {file_info['relative_path']}
**Generated**: {datetime.now().strftime('%Y-%m-%d')}
**Category**: {file_info['category']}

## Information

"""
    
    # Include key sections
    for section in metadata['sections'][:8]:
        content += f"- {section}\n"
    
    content += f"""
## Metadata
- **File Size**: {file_info.get('file_size', 0)} bytes
- **Content Length**: {file_info.get('content_length', 0)} characters
- **Keywords**: {', '.join(metadata['keywords'])}
- **Has Implementation Details**: {metadata['has_implementation_details']}
- **Has Technical Specs**: {metadata['has_technical_specs']}

## Status
- **Processing**: ✅ Complete
- **Documentation**: ✅ Generated

---
*General documentation generated from completed planning analysis*
"""
    
    return content

def convert_files_to_documentation(analysis_file, docs_dir):
    """Convert files to proper documentation"""
    
    with open(analysis_file, 'r') as f:
        analysis_results = json.load(f)
    
    docs_path = Path(docs_dir)
    converted_files = []
    
    # Create documentation directories
    categories = ['cli', 'backend', 'infrastructure', 'security', 'exchange', 'blockchain', 'analytics', 'maintenance', 'implementation', 'testing', 'general']
    for category in categories:
        (docs_path / category).mkdir(parents=True, exist_ok=True)
    
    for result in analysis_results['analysis_results']:
        if 'error' in result:
            continue
        
        file_info = result
        metadata = result['documentation_metadata']
        action = result['recommended_action']
        target_category = result['target_category']
        
        # Generate documentation content based on action
        if action == 'convert_to_technical_doc':
            content = create_technical_documentation(file_info, metadata)
        elif action == 'convert_to_status_doc':
            content = create_status_documentation(file_info, metadata)
        elif action == 'convert_to_analysis_doc':
            content = create_analysis_documentation(file_info, metadata)
        elif action == 'convert_to_summary_doc':
            content = create_summary_documentation(file_info, metadata)
        else:
            content = create_general_documentation(file_info, metadata)
        
        # Create documentation file
        safe_filename = re.sub(r'[^a-zA-Z0-9_-]', '_', metadata['title'])[:50]
        filename = f"documented_{safe_filename}.md"
        filepath = docs_path / target_category / filename
        
        # Write documentation
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(content)
        
        converted_files.append({
            'original_file': file_info['file_path'],
            'original_category': file_info['category'],
            'documentation_file': str(filepath),
            'target_category': target_category,
            'title': metadata['title'],
            'action': action,
            'keywords': metadata['keywords']
        })
        
        print(f"Converted: {file_info['relative_path']} -> {target_category}/{filename}")
    
    return converted_files

if __name__ == "__main__":
    analysis_file = 'content_analysis_results.json'
    docs_dir = '/opt/aitbc/docs'
    
    converted_files = convert_files_to_documentation(analysis_file, docs_dir)
    
    print(f"Documentation conversion complete:")
    print(f"  Converted {len(converted_files)} files to documentation")
    
    # Save conversion results
    with open('documentation_conversion_final.json', 'w') as f:
        json.dump(converted_files, f, indent=2)