import acrcloud
import os
import eyed3
import requests
import json
from acrcloud.recognizer import ACRCloudRecognizer



# ACR Cloud setup
config = {
    'host': ACR_HOST,
    'access_key': ACR_ACCESS_KEY,
    'access_secret': ACR_ACCESS_SECRET,
    'timeout': 10  # seconds
}
dir(acrcloud)

# Initialize the ACRCloud recognizer
recognizer = ACRCloudRecognizer(config)

# Function to recognize the song from an audio file
def recognize_song(audio_file_path):
    buffer = open(audio_file_path, 'rb').read()
    result = recognizer.recognize_by_filebuffer(buffer, 0)
    try:
        result_dict = json.loads(result)  # Parse the JSON string into a dictionary
        return result_dict['metadata']['music'][0]
    except (KeyError, IndexError, json.JSONDecodeError) as e:
        print(f"Error while parsing result: {e}")
        return None

# Function to set ID3 tags
def set_id3_tags_mp3(audio_file_path, tags):
    audio_file = eyed3.load(audio_file_path)
    if not audio_file.tag:
        audio_file.initTag()

    audio_file.tag.artist = tags.get('artists')[0].get('name')
    audio_file.tag.album = tags.get('album').get('name')
    audio_file.tag.album_artist = tags.get('artists')[0].get('name')
    audio_file.tag.title = tags.get('title')

     # Set the release year (if available)
    release_date = tags.get('release_date')
    if release_date and len(release_date) >= 4:  # Check if release_date contains at least the year
        year_string = release_date[:4]
        try:
            year = int(year_string)
            # Some versions of eyeD3 require a Date object if available
            if hasattr(eyed3.id3.tag, 'Date'):
                audio_file.tag.recording_date = eyed3.id3.tag.Date(year)
            else:
                # Otherwise, set it as text_frame
                audio_file.tag.setTextFrame("TDRC", year_string)
        except ValueError:
            print(f"Invalid date format in the tag: {release_date}")

    # Add more tags here
    audio_file.tag.genre = tags.get('genres')[0].get('name')  # Assuming there's at least one genre
    audio_file.tag.publisher = "Karthik"  # Publisher tag set as 'karthik'
    
    # To save the copyright label:
    audio_file.tag.copyright = tags.get('label', '')
    
    # To save the album cover page, you would need to download the image from a source 
    # and then do something like this:
    # with open("path_to_cover_image.jpg", "rb") as album_art:
    #     audio_file.tag.images.set(3, album_art.read(), "image/jpeg", u"Description")
  
    
    audio_file.tag.save(version=eyed3.id3.ID3_V2_3)

    audio_file.tag.save()

# Replace 'path_to_your_audio_file.mp3' with the actual file path of the unknown song
if __name__ == "__main__":
    audio_file_path = 'C:/Users/ILEG-i5-11/Downloads/Music/Unknown_file.mp3'
    song_tags = recognize_song(audio_file_path)
    if song_tags:
        print(f'Song identified: {song_tags}')
        set_id3_tags_mp3(audio_file_path, song_tags)

        # Renaming the file after identifying the song and setting tags
        artist_name = song_tags.get('artists')[0].get('name')
        song_title = song_tags.get('title')
        if artist_name and song_title:
            new_file_name = f"{artist_name} - {song_title}.mp3"
            new_file_path = os.path.join(os.path.dirname(audio_file_path), new_file_name)
            os.rename(audio_file_path, new_file_path)
            print(f"File has been renamed to: {new_file_name}")

    else:
        print('Could not identify the song.')


import json
import requests
from acrcloud.recognizer import ACRCloudRecognizer
from musixmatch_api import Musixmatch, CaptchaError, UserTokenError
from mutagen.mp3 import MP3
from mutagen.id3 import ID3, APIC, error



# ACR Cloud configuration (update with your credentials)
config = {
    'host': ACR_HOST,
    'access_key': ACR_ACCESS_KEY,
    'access_secret': ACR_ACCESS_SECRET,
    'timeout': 10  # seconds
}

recognizer = ACRCloudRecognizer(config)

# Initialize Musixmatch API (exception handling to be added as per your implementation)
musixmatch = Musixmatch(Exception)

# Function to recognize a song using ACRCloud
def recognize_song(audio_file_path):
    buffer = open(audio_file_path, 'rb').read()
    result = recognizer.recognize_by_filebuffer(buffer, 0)
    try:
        result_dict = json.loads(result)
        return result_dict['metadata']['music'][0]
    except (KeyError, IndexError, json.JSONDecodeError) as e:
        print(f"Error while parsing result: {e}")
        return None

def format_time(ts):
    '''Converts time in seconds to the format [mm:ss.xx]'''
    minutes = int(ts // 60)
    seconds = int(ts % 60)
    hundredths = int((ts - int(ts)) * 100)
    return f'[{minutes:02d}:{seconds:02d}.{hundredths:02d}]'

def process_rich_sync_lyrics(rich_sync_lyrics_json):
    '''Converts Musixmatch rich sync data to LRC format'''
    lrc_lines = []
    try:
        # Load the JSON string into a Python object
        rich_sync_data = json.loads(rich_sync_lyrics_json)
    except json.JSONDecodeError as e:
        print(f"Error decoding JSON: {e}")
        return None

    # Iterate through each line and create formatted LRC lines
    for line in rich_sync_data:
        ts = format_time(line['ts'])  # Start time of the line
        lrc_line = f'{ts}{line["x"]}'  # Use "x" for the entire line of lyrics
        lrc_lines.append(lrc_line)

    # Join the formatted lines with line breaks
    return '\n'.join(lrc_lines)


# Function to get lyrics from Musixmatch given artist name and song title
def get_lyrics_from_musicxmatch(artist_name, song_title):
    try:
        user_token = musixmatch.get_user_token()
        
        track_data = musixmatch.get_search_by_track(song_title, artist_name, "")
        if track_data:
            track_id = track_data['track_id']
            rich_sync_data = musixmatch.get_rich_sync_by_id(track_id)
            
            # Print the JSON response for debugging
            print(json.dumps(track_data, indent=2))
            print(json.dumps(rich_sync_data, indent=2))

            if rich_sync_data and 'richsync_body' in rich_sync_data:
                rich_sync_lyrics_json = rich_sync_data['richsync_body']
                lrc_lyrics = process_rich_sync_lyrics(rich_sync_lyrics_json)
                return lrc_lyrics
            else:
                print("No synced lyrics found.")
                return None
        else:
            print("Track not found in Musixmatch.")
            return None
    except (CaptchaError, UserTokenError) as e:
        print(f"Error while working with Musixmatch: {e}")
        return None

if __name__ == "__main__":
    audio_file_path = 'C:/Users/ILEG-i5-11/Downloads/Music/Unknown_file.mp3'  # Replace with actual path
    lrc_file_path = 'C:/Users/ILEG-i5-11/Downloads/Music/Unknown_file.lrc'  # Output LRC file path

    # Recognize the song using ACRCloud
    song_tags = recognize_song(audio_file_path)
    if song_tags:
        artist_name = song_tags['artists'][0]['name']
        song_title = song_tags['title']
        print(f"Identified Song: {artist_name} - {song_title}")

        # Fetch track data using the recognized song's title and artist name
        track_data = musixmatch.get_search_by_track(song_title, artist_name)
        if track_data:
            track_id = track_data['track_id']            

            # Fetch the synced lyrics using the recognized song's track ID
            rich_sync_data = musixmatch.get_rich_sync_by_id(track_id)
            if rich_sync_data and 'richsync_body' in rich_sync_data:
                rich_sync_lyrics_json = rich_sync_data['richsync_body']
                lrc_lyrics = process_rich_sync_lyrics(rich_sync_lyrics_json)
                if lrc_lyrics:
                    # Write the LRC lyrics to a file
                    with open(lrc_file_path, 'w', encoding='utf-8') as lrc_file:
                        lrc_file.write(lrc_lyrics)
                    print(f"Saved LRC file to: {lrc_file_path}")
                else:
                    print("No synced lyrics found.")
        else:
            print("Track not found in Musixmatch.")
    else:
        print("Could not identify the song.")


use these both codes: and combine into one 

parameters to include to tagging a audio file are: 
Title, contributing artists, artists, album, year of released, track index number in album,  genre, copyright label, composer's name, published by Karthik.
get these by musixmatch