import os
import time
import json
import logging
from metadata import MetadataExtractor
from db_operations import DatabaseManager

class MusicScanner:
    def __init__(self, config):
        self.nas_paths = config['music']['paths']
        self.supported_formats = config['music']['formats']
        self.db_manager = DatabaseManager(config['database']['path'])
        self.metadata_extractor = MetadataExtractor()
        self.logger = self._setup_logger()
    
    def _setup_logger(self):
        logger = logging.getLogger('music_scanner')
        logger.setLevel(logging.INFO)
        
        handler = logging.FileHandler('scanner.log')
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        handler.setFormatter(formatter)
        
        logger.addHandler(handler)
        return logger
    
    def scan_library(self):
        """Scan all configured music directories and update the database"""
        start_time = time.time()
        self.logger.info("Starting music library scan")
        
        for music_path in self.nas_paths:
            if not os.path.exists(music_path):
                self.logger.error(f"Music path does not exist: {music_path}")
                continue
                
            self.logger.info(f"Scanning directory: {music_path}")
            self._scan_directory(music_path)
        
        elapsed_time = time.time() - start_time
        self.logger.info(f"Scan completed in {elapsed_time:.2f} seconds")
        
        stats = self.db_manager.get_stats()
        self.logger.info(f"Library stats: {json.dumps(stats)}")
        
        return stats
    
    def _scan_directory(self, directory):
        """Recursively scan a directory for music files"""
        for root, dirs, files in os.walk(directory):
            for file in files:
                if self._is_supported_format(file):
                    file_path = os.path.join(root, file)
                    self._process_file(file_path)
    
    def _is_supported_format(self, filename):
        """Check if the file has a supported music format"""
        ext = os.path.splitext(filename)[1].lower().lstrip('.')
        return ext in self.supported_formats
    
    def _process_file(self, file_path):
        """Extract metadata and add the file to the database"""
        try:
            metadata = self.metadata_extractor.extract(file_path)
            
            if not metadata:
                self.logger.warning(f"Could not extract metadata from: {file_path}")
                return
            
            # Add artist
            artist_id = self.db_manager.add_artist(metadata.get('artist', 'Unknown Artist'))
            
            # Add album
            album_id = self.db_manager.add_album(
                metadata.get('album', 'Unknown Album'),
                artist_id,
                metadata.get('year'),
                metadata.get('cover_path')
            )
            
            # Add track
            track_data = {
                'title': metadata.get('title', os.path.basename(file_path)),
                'artist_id': artist_id,
                'album_id': album_id,
                'genre': metadata.get('genre'),
                'duration': metadata.get('duration'),
                'track_number': metadata.get('track_number'),
                'file_path': file_path,
                'file_format': os.path.splitext(file_path)[1].lower().lstrip('.'),
                'bitrate': metadata.get('bitrate')
            }
            
            track_id = self.db_manager.add_track(track_data)
            
        except Exception as e:
            self.logger.error(f"Error processing file {file_path}: {str(e)}")

    def cleanup(self):
        """Close database connection"""
        self.db_manager.close()