class InteriorDesignApp {
    constructor() {
        console.log('InteriorDesignApp constructor called');
        
        this.canvas = document.getElementById('designCanvas');
        console.log('Canvas found:', this.canvas);
        
        if (!this.canvas) {
            throw new Error('Canvas element not found');
        }
        
        this.ctx = this.canvas.getContext('2d');
        console.log('Canvas context:', this.ctx);
        
        this.designElements = [];
        
        console.log('Basic properties initialized');
        
        // Initialize core managers
        console.log('Initializing managers...');
        
        this.canvasManager = new CanvasManager(this.canvas, this.ctx);
        console.log('CanvasManager initialized');
        
        this.roomManager = new RoomManager(this.canvasManager);
        console.log('RoomManager initialized');
        
        this.wallManager = new WallManager(this.canvasManager);
        console.log('WallManager initialized');
        
        this.floorManager = new FloorManager(this.canvasManager);
        console.log('FloorManager initialized');
        
        this.symbolManager = new SymbolManager(this.canvasManager);
        console.log('SymbolManager initialized');
        
        this.zoomPanManager = new ZoomPanManager(this.canvasManager);
        console.log('ZoomPanManager initialized');
        
        this.threeJSManager = new ThreeJSManager(this.canvas);
        console.log('ThreeJSManager initialized');
        
        this.uiManager = new UIManager(this.roomManager, this.wallManager);
        console.log('UIManager initialized');
        
        // Initialize new managers
        this.toolManager = new ToolManager(this);
        console.log('ToolManager initialized');
        
        this.interactionManager = new InteractionManager(this);
        console.log('InteractionManager initialized');
        
        this.eventManager = new EventManager(this);
        console.log('EventManager initialized');
        
        this.cameraControlsManager = new CameraControlsManager(this);
        console.log('CameraControlsManager initialized');
        
        this.viewManager = new ViewManager(this);
        console.log('ViewManager initialized');
        
        this.canvasDrawingManager = new CanvasDrawingManager(this);
        console.log('CanvasDrawingManager initialized');
        
        this.designManager = new DesignManager(this);
        console.log('DesignManager initialized');
        
        this.unitManager = new UnitManager();
        console.log('UnitManager initialized');
        
        this.historyManager = new HistoryManager(this);
        console.log('HistoryManager initialized');
        
        // Setup additional UI handlers
        this.setupUIHandlers();
        
        console.log('Calling init...');
        this.init();
        console.log('App fully initialized');
    }

    init() {
        this.eventManager.setupEventListeners();
        this.canvasDrawingManager.setupCanvas();
        this.cameraControlsManager.setup3DCameraControls();
        console.log('Init complete');
    }

    // Delegate methods to appropriate managers
    setTool(tool) {
        this.toolManager.setTool(tool);
    }

    // View management methods
    switchTo2D() {
        this.viewManager.switchTo2D();
    }

    switchTo3D() {
        this.viewManager.switchTo3D();
    }

    toggleView() {
        this.viewManager.toggleView();
    }

    convertTo3D() {
        this.viewManager.convertTo3D();
    }

    // Zoom and pan methods
    zoomIn() {
        this.viewManager.zoomIn();
    }

    zoomOut() {
        this.viewManager.zoomOut();
    }

    resetZoom() {
        this.viewManager.resetZoom();
    }

    // Display toggle methods
    toggleGrid() {
        this.viewManager.toggleGrid();
    }

    toggleMeasurements() {
        this.viewManager.toggleMeasurements();
    }

    toggleSnap() {
        this.viewManager.toggleSnap();
    }

    // Drawing and canvas methods
    redraw() {
        this.canvasDrawingManager.redraw();
    }

    isPointInElement(x, y, element) {
        return this.canvasDrawingManager.isPointInElement(x, y, element);
    }

    deleteElement() {
        this.canvasDrawingManager.deleteElement();
    }

    // Design management methods
    saveDesign() {
        this.designManager.saveDesign();
    }

    newDesign() {
        this.designManager.newDesign();
    }

    updateRoomName(name) {
        this.designManager.updateRoomName(name);
    }

    updateWallThickness(thickness) {
        this.designManager.updateWallThickness(thickness);
    }

    debugTest() {
        this.designManager.debugTest();
    }

    // 3D controls setup (delegated to CameraControlsManager)
    setup3DControlsDragAndScale() {
        this.cameraControlsManager.setup3DControlsDragAndScale();
    }

    // History management methods
    undo() {
        this.historyManager.undo();
    }

    redo() {
        this.historyManager.redo();
    }

    saveHistory() {
        this.historyManager.saveState();
    }
    
    // Setup additional UI handlers
    setupUIHandlers() {
        // Color picker value display
        const colorPicker = document.getElementById('colorPickerTop');
        const colorValue = document.getElementById('colorValue');
        
        if (colorPicker && colorValue) {
            colorPicker.addEventListener('input', (e) => {
                colorValue.textContent = e.target.value;
            });
        }
        
        // Unit display update
        const unitsSelect = document.getElementById('unitsSelect');
        const currentUnit = document.getElementById('currentUnit');
        
        if (unitsSelect && currentUnit) {
            unitsSelect.addEventListener('change', (e) => {
                currentUnit.textContent = e.target.value;
            });
        }
        
        // Grid size input
        const gridSizeInput = document.getElementById('gridSizeInput');
        const gridUnitLabel = document.getElementById('gridUnitLabel');
        
        if (gridSizeInput && gridUnitLabel && unitsSelect) {
            unitsSelect.addEventListener('change', (e) => {
                gridUnitLabel.textContent = e.target.value;
            });
        }
    }
}

// Initialize the application when the page loads
let app;
document.addEventListener('DOMContentLoaded', () => {
    console.log('DOM Content Loaded - Initializing app...');
    
    // Check if required elements exist
    const canvas = document.getElementById('designCanvas');
    const roomToolTop = document.getElementById('roomToolTop');
    const wallToolTop = document.getElementById('wallToolTop');
    
    console.log('Canvas element:', canvas);
    console.log('Room tool (top):', roomToolTop);
    console.log('Wall tool (top):', wallToolTop);
    
    if (!canvas) {
        console.error('Canvas element not found!');
        return;
    }
    
    if (!roomToolTop && !wallToolTop) {
        console.error('No tool buttons found! Checking for fallback buttons...');
        const roomTool = document.getElementById('roomTool');
        const wallTool = document.getElementById('wallTool');
        console.log('Fallback Room tool:', roomTool);
        console.log('Fallback Wall tool:', wallTool);
        
        if (!roomTool && !wallTool) {
            console.error('No tool buttons found at all!');
            // Continue anyway - the app might still work
        }
    }
    
    try {
        // Test canvas functionality
        if (canvas) {
            const ctx = canvas.getContext('2d');
            if (ctx) {
                console.log('Canvas context available');
                // Draw a test rectangle to verify canvas works
                ctx.fillStyle = 'red';
                ctx.fillRect(10, 10, 50, 50);
                console.log('Test rectangle drawn');
            } else {
                console.error('Cannot get canvas context');
            }
        }
        
        app = new InteriorDesignApp();
        window.app = app; // Make app globally accessible
        console.log('App initialized successfully:', app);
        
        // Test tool setting
        setTimeout(() => {
            console.log('Testing tool setting...');
            app.setTool('pointer');
            console.log('Current tool after test:', app.toolManager.getCurrentTool());
        }, 1000);
        
    } catch (error) {
        console.error('Error initializing app:', error);
        console.error('Error stack:', error.stack);
    }
});