import gradio as gr
import subprocess
import os
import tempfile
import datetime
from pathlib import Path
from huggingface_hub import upload_file
from typing import Optional, Tuple, List, Union
import logging
import shutil

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class ImageToDxfConverter:
    def __init__(self):
        """Initialize the converter with configuration."""
        # For Hugging Face Spaces, executable should be in the root directory
        self.executable_path = Path("SimpleImageToDxfHavePass")
        self.hf_token = os.getenv("HF_TOKEN")
        self.repo_id = "ArrcttacsrjksX/ImageToAutocadData"
        
        # Make executable file executable (Hugging Face Spaces specific)
        try:
            os.chmod(self.executable_path, 0o755)
            logger.info(f"Set executable permissions for {self.executable_path}")
        except Exception as e:
            logger.error(f"Failed to set executable permissions: {e}")

    def _ensure_directory(self, path: Union[str, Path]) -> Path:
        """Ensure directory exists and return Path object."""
        path = Path(path)
        path.mkdir(parents=True, exist_ok=True)
        return path

    def _generate_output_paths(self, output_folder: Path, timestamp: str) -> dict:
        """Generate all required output paths."""
        return {
            'output_dxf': output_folder / f"{timestamp}_output.dxf",
            'debug_png': output_folder / f"{timestamp}_debug.png",
            'temp_dxf': output_folder / "_output.dxf",
            'temp_debug': output_folder / "_debug.png"
        }

    def convert_image(self, 
                     image_path: Optional[str], 
                     output_folder: Optional[str] = None,
                     use_lines: bool = False) -> Tuple[Optional[str], Optional[str], List[str]]:
        """Convert image to DXF format."""
        try:
            # Input validation
            if not image_path:
                return "No image provided", None, []

            # Setup output directory
            output_dir = self._ensure_directory(output_folder if output_folder else tempfile.mkdtemp())
            timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
            paths = self._generate_output_paths(output_dir, timestamp)

            # Prepare conversion command
            command = [
                f"./{self.executable_path}",  # Use relative path with ./
                f"--imagePath={image_path}",
                f"--outputPath={paths['temp_dxf']}",
                f"--debug-output={paths['temp_debug']}"
            ]
            if use_lines:
                command.append("--use-lines")

            # Execute conversion
            try:
                result = subprocess.run(
                    command,
                    check=True,
                    capture_output=True,
                    text=True
                )
                logger.info(f"Conversion output: {result.stdout}")
            except subprocess.CalledProcessError as e:
                error_msg = f"Conversion failed: {e.stderr}"
                logger.error(error_msg)
                return error_msg, None, []

            # Move temporary files to final locations
            shutil.move(paths['temp_dxf'], paths['output_dxf'])
            if use_lines and os.path.exists(paths['temp_debug']):
                shutil.move(paths['temp_debug'], paths['debug_png'])

            # Upload files to Hugging Face
            uploaded_files = []
            if self.hf_token:
                try:
                    date_folder = timestamp
                    
                    # Upload input image
                    uploaded_input = upload_file(
                        path_or_fileobj=image_path,
                        path_in_repo=f"datasets/{self.repo_id}/{date_folder}/{Path(image_path).name}",
                        repo_id=self.repo_id,
                        token=self.hf_token
                    )
                    uploaded_files.append(uploaded_input)

                    # Upload DXF output
                    uploaded_dxf = upload_file(
                        path_or_fileobj=str(paths['output_dxf']),
                        path_in_repo=f"datasets/{self.repo_id}/{date_folder}/{paths['output_dxf'].name}",
                        repo_id=self.repo_id,
                        token=self.hf_token
                    )
                    uploaded_files.append(uploaded_dxf)

                    # Upload debug image if available
                    if use_lines and os.path.exists(paths['debug_png']):
                        uploaded_debug = upload_file(
                            path_or_fileobj=str(paths['debug_png']),
                            path_in_repo=f"datasets/{self.repo_id}/{date_folder}/{paths['debug_png'].name}",
                            repo_id=self.repo_id,
                            token=self.hf_token
                        )
                        uploaded_files.append(uploaded_debug)
                except Exception as e:
                    logger.error(f"Upload failed: {str(e)}")

            return (
                str(paths['output_dxf']),
                str(paths['debug_png']) if use_lines and os.path.exists(paths['debug_png']) else None,
                uploaded_files
            )

        except Exception as e:
            error_msg = f"Conversion failed: {str(e)}"
            logger.error(error_msg)
            return error_msg, None, []

def create_gradio_interface():
    """Create and configure the Gradio interface."""
    converter = ImageToDxfConverter()
    
    with gr.Blocks(theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # Image to DXF Converter
        Convert your images to DXF format for CAD software.
        """)
        
        with gr.Row():
            with gr.Column(scale=2):
                image_input = gr.Image(
                    type="filepath",
                    label="Input Image",
                    elem_id="image_input"
                )
            with gr.Column(scale=1):
                output_folder = gr.Textbox(
                    label="Output Folder (optional)",
                    placeholder="Leave blank for temporary folder",
                    elem_id="output_folder"
                )
                use_lines_checkbox = gr.Checkbox(
                    label="Enable line detection",
                    value=False,
                    elem_id="use_lines"
                )
                convert_btn = gr.Button(
                    "Convert to DXF",
                    variant="primary"
                )

        with gr.Row():
            with gr.Column():
                dxf_output = gr.File(
                    label="DXF Output",
                    elem_id="dxf_output"
                )
            with gr.Column():
                debug_output = gr.Image(
                    type="filepath",
                    label="Debug Preview",
                    elem_id="debug_output"
                )
        
        status_output = gr.Textbox(
            label="Status",
            value="Ready",
            interactive=False
        )

        # Event handler
        convert_btn.click(
            fn=converter.convert_image,
            inputs=[image_input, output_folder, use_lines_checkbox],
            outputs=[dxf_output, debug_output, status_output]
        )

    return demo

def main():
    """Main entry point with proper error handling."""
    try:
        demo = create_gradio_interface()
        demo.launch(
            server_name="0.0.0.0",
            server_port=7860
        )
    except Exception as e:
        logger.critical(f"Application failed to start: {str(e)}")
        raise

if __name__ == "__main__":
    main()