class WallManager {
    constructor(canvasManager) {
        this.canvasManager = canvasManager;
        this.ctx = canvasManager.ctx;
        this.wallThickness = 10;
    }

    // Create wall element
    createWallElement(startX, startY, endX, endY, material, color) {
        const distance = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2));
        
        return {
            id: Date.now().toString(),
            type: 'wall',
            startX: startX,
            startY: startY,
            endX: endX,
            endY: endY,
            material: material,
            color: color,
            thickness: this.wallThickness,
            length: distance
        };
    }

    // Draw wall preview while dragging
    drawWallPreview(startX, startY, endX, endY) {
        const thickness = this.wallThickness;
        const angle = Math.atan2(endY - startY, endX - startX);
        const perpX = Math.cos(angle + Math.PI / 2) * thickness / 2;
        const perpY = Math.sin(angle + Math.PI / 2) * thickness / 2;

        // Draw wall outline
        this.ctx.beginPath();
        this.ctx.moveTo(startX + perpX, startY + perpY);
        this.ctx.lineTo(endX + perpX, endY + perpY);
        this.ctx.lineTo(endX - perpX, endY - perpY);
        this.ctx.lineTo(startX - perpX, startY - perpY);
        this.ctx.closePath();
        this.ctx.stroke();

        // Draw center line
        this.ctx.beginPath();
        this.ctx.moveTo(startX, startY);
        this.ctx.lineTo(endX, endY);
        this.ctx.stroke();
    }

    // Draw wall measurement
    drawWallMeasurement(startX, startY, endX, endY) {
        const distance = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2));
        this.canvasManager.drawMeasurement(startX, startY, endX, endY, `${Math.round(distance)}px`);
    }

    // Draw wall element
    drawWall(element) {
        // Draw wall with thickness
        const thickness = element.thickness || this.wallThickness;
        const angle = Math.atan2(element.endY - element.startY, element.endX - element.startX);
        const perpX = Math.cos(angle + Math.PI / 2) * thickness / 2;
        const perpY = Math.sin(angle + Math.PI / 2) * thickness / 2;

        // Fill wall area
        this.ctx.beginPath();
        this.ctx.moveTo(element.startX + perpX, element.startY + perpY);
        this.ctx.lineTo(element.endX + perpX, element.endY + perpY);
        this.ctx.lineTo(element.endX - perpX, element.endY - perpY);
        this.ctx.lineTo(element.startX - perpX, element.startY - perpY);
        this.ctx.closePath();
        this.ctx.fill();
        this.ctx.stroke();

        // Draw center line
        this.ctx.strokeStyle = element.color;
        this.ctx.lineWidth = 1;
        this.ctx.setLineDash([2, 2]);
        this.ctx.beginPath();
        this.ctx.moveTo(element.startX, element.startY);
        this.ctx.lineTo(element.endX, element.endY);
        this.ctx.stroke();
        this.ctx.setLineDash([]);

        // Show measurement if enabled
        if (this.canvasManager.showMeasurements && element.length) {
            const midX = (element.startX + element.endX) / 2;
            const midY = (element.startY + element.endY) / 2;
            this.ctx.fillStyle = '#333';
            this.ctx.font = '10px Arial';
            this.ctx.textAlign = 'center';
            this.ctx.fillText(`${Math.round(element.length)}px`, midX, midY - 15);
        }
    }

    // Find wall connections for snapping
    findWallConnection(x, y, designElements) {
        const snapDistance = 10;
        
        for (const element of designElements) {
            if (element.type === 'wall') {
                // Check start point
                const startDist = Math.sqrt(Math.pow(x - element.startX, 2) + Math.pow(y - element.startY, 2));
                if (startDist < snapDistance) {
                    return { x: element.startX, y: element.startY };
                }
                
                // Check end point
                const endDist = Math.sqrt(Math.pow(x - element.endX, 2) + Math.pow(y - element.endY, 2));
                if (endDist < snapDistance) {
                    return { x: element.endX, y: element.endY };
                }
            }
        }
        
        return null;
    }

    drawConnectionIndicator(connection) {
        if (connection) {
            this.ctx.fillStyle = '#ff6b6b';
            this.ctx.beginPath();
            this.ctx.arc(connection.x, connection.y, 5, 0, 2 * Math.PI);
            this.ctx.fill();
        }
    }

    // Check if point is on wall
    isPointOnWall(x, y, element) {
        if (element.type !== 'wall') return false;
        
        // Simple line distance check
        const distance = Math.abs((element.endY - element.startY) * x - 
                                (element.endX - element.startX) * y + 
                                element.endX * element.startY - 
                                element.endY * element.startX) /
                       Math.sqrt(Math.pow(element.endY - element.startY, 2) + 
                                Math.pow(element.endX - element.startX, 2));
        return distance < 10;
    }

    // Update wall thickness
    updateWallThickness(element, thickness) {
        if (element && element.type === 'wall') {
            element.thickness = parseInt(thickness);
            return true;
        }
        return false;
    }

    // Update global wall thickness
    updateGlobalWallThickness(thickness) {
        this.wallThickness = parseInt(thickness);
        const wallThicknessValue = document.getElementById('wallThicknessValue');
        if (wallThicknessValue) {
            wallThicknessValue.textContent = thickness;
        }
    }

    // Get wall properties for UI
    getWallProperties(element) {
        if (element.type !== 'wall') return null;
        
        return {
            length: Math.round(element.length || 0),
            thickness: element.thickness || this.wallThickness
        };
    }
}