#!/usr/bin/env python3

import os
import sys
import shutil
from pathlib import Path

import logging

import mimetypes
import subprocess

from typing import TypedDict
from typing import Optional

import re

import requests
from bs4 import BeautifulSoup

from mutagen.id3 import ID3
from mutagen.id3 import TPE1, TIT2, TALB
from mutagen.id3 import TYER, TRCK
from mutagen.id3 import USLT, APIC

BASEURL = 'https://www.azlyrics.com'
USERAGENT = (
    'Mozilla/5.0 (X11; Linux x86_64; rv:109.0) '
    'Gecko/20100101 Firefox/110.0'
)

LYRICS_ROW = '.main-page>.row>.col-xs-12'

session = requests.Session()
session.headers['User-Agent'] = USERAGENT


class ParseResult(TypedDict):
    title: str
    artist: str
    album: str
    year: int
    track_no: int
    tracks: int
    lyrics: str
    cover: Optional[bytes]
    cover_mime: Optional[str]


class ParseError(Exception):

    def __init__(self, parsing_obj: str) -> None:

        super().__init__(
            f'Unable to parse {parsing_obj}'
        )


def main() -> None:

    copy = int(sys.argv[1]) == 1
    file = sys.argv[2]

    title = conv_title(file)
    print(
        'Enter new title to correct it, '
        'or press Enter to continue',
        '"!--" without quotes means that '
        'you want to enter info and lyrics manually',
        sep='\n',
    )
    print('Title:', title)
    correct = input().strip()

    parsed: Optional[ParseResult] = None

    if correct == '!--':
        parsed = manual_info_input()
    else:
        if correct != '':
            title = correct.lower()
        url = search_azurl(title)
        print(url)
        parsed = parse_azlyrics(url)

    #print(parsed)
    tagmp3(file, parsed, copy)


def input_num(msg: str, def_: int = 0) -> int:

    try:
        return int(input(msg))
    except ValueError:
        return def_


def conv_title(file: str) -> str:

    # Remove file path
    title = file \
        .replace('./convert/', '') \
        .replace('./files/', '')

    # Remove a YT ID and an extension
    title = re.sub(
        r'-{3}[\w_-]*\.[\w_-]*',
        '', title,
    )

    # Remove "(Official Audio)"
    title = re.sub(
        r'\(.*\)',
        '', title,
    )

    # underscore -> space
    title = title \
        .replace('_', ' ') \
        .strip() \
        .lower()

    return title


def search_azurl(title: str) -> str:

    print('Searching...')
    
    page = session.get(
        'https://searx.dc09.ru/search',
        params={
            'q': f'{title} site:azlyrics.com',
            'category_general': 1,
            'language': 'ru-RU',
            'time_range': '',
            'safesearch': 0,
            'theme': 'simple',
        },
    )

    soup = BeautifulSoup(page.text, 'html.parser')
    link = soup.select_one(
        'div#urls>article>h3>a[href*="azlyrics.com/lyrics/"]'
    )

    if link is None:
        raise ParseError('song URL')
    
    return str(link.get('href'))


def parse_azlyrics(link: str) -> ParseResult:

    result = ParseResult(
        title='', artist='',
        album='', year=0,
        track_no=0, tracks=0,
        lyrics='',
        cover=None,
        cover_mime=None,
    )

    print('Please wait...')

    page = session.get(link)
    soup = BeautifulSoup(page.text, 'html.parser')
    
    lyrics = soup.select_one(
        f'{LYRICS_ROW}>div'
        ':not(.div-share)'
        ':not(.lyricsh)'
        ':not(.ringtone)'
    )
    if lyrics is None:
        raise ParseError('song lyrics')
    result['lyrics'] = lyrics.get_text().strip()

    artist_elem = soup.select_one(f'{LYRICS_ROW}>.lyricsh>h2')
    if artist_elem is None:
        print('Unable to parse artist name')
        result['artist'] = input('Enter the artist name: ')
    else:
        result['artist'] = artist_elem.get_text() \
            .removesuffix(' Lyrics') \
            .strip()

    title_elem = soup.select_one(f'{LYRICS_ROW}>b')
    if title_elem is None:
        print('Unable to parse song title')
        result['title'] = input('Enter the title: ')
    else:
        result['title'] = title_elem.get_text().strip('" ')

    album_blocks = soup.select('.songinalbum_title')
    album = None

    if len(album_blocks) > 1:
        album = album_blocks[-2]

    elif len(album_blocks) > 0:
        album = album_blocks[0]
    
    if album is None:
        album_re = None
    else:
        album_re = re.search(
            r'album:\s*"(.+?)"\s*\((\d+)\)',
            album.get_text()
        )

    if album_re is None:
        print('Unable to parse album name')
        result['album'] = input('Enter the album name: ')
        result['year'] = input_num('Enter the release year: ')
        result['track_no'] = input_num('This is the track #')
        result['tracks'] = input_num('Number of tracks in the album: ')

        cover = input('Insert an album cover? [Y/n] ')
        if cover.lower() not in ('n','н'):
            try:
                print(
                    'Download the cover and enter its path:',
                    '(relative path is not recommended)',
                    sep='\n',
                )
                cover_file = Path(input().strip())

                with cover_file.open('rb') as f:
                    result['cover'] = f.read()

                result['cover_mime'] = (
                    mimetypes.guess_type(cover_file)[0]
                    or 'image/jpeg'
                )
            except Exception as err:
                logging.exception(err)

    else:
        result['album'] = album_re[1]
        result['year'] = int(album_re[2])

        assert album is not None
        cover = album.select_one('img.album-image')

        if cover is not None:

            cover_url = str(cover.get('src'))
            if cover_url.startswith('/'):
                cover_url = BASEURL + cover_url

            req = session.get(cover_url)
            result['cover'] = req.content
            result['cover_mime'] = req.headers.get(
                'Content-Type', 'image/jpeg'
            )
    
        tracklist_elem = soup.select_one('.songlist-panel')
        if tracklist_elem is not None:

            tracklist = tracklist_elem.select(
                '.listalbum-item'
            )
            result['tracks'] = len(tracklist)

            current_url = re.search(
                r'/(lyrics/.+?\.html)',
                link,
            )

            result['track_no'] = 0
            if current_url is not None:
                for i, track in enumerate(tracklist):

                    track_url = track.select_one('a')
                    if track_url is None:
                        continue

                    track_href = str(track_url.get('href'))
                    if current_url[0] in track_href:
                        result['track_no'] = (i + 1)
                        break

    return result


def manual_info_input() -> ParseResult:

    result = ParseResult(
        title=input('Song title: '),
        artist=input('Artist name: '),
        album=input('Album name: '),
        year=input_num('Release year: '),
        track_no=input_num('Track #'),
        tracks=input_num('Tracks in album: '),
        lyrics='', cover=None, cover_mime=None,
    )

    editor = os.getenv('EDITOR', 'nano')
    print('Now, paste the lyrics into a text editor')
    print(f'Default editor: {editor}')
    print('Enter another or press Enter to continue')
    other_editor = input().strip()

    if other_editor != '':
        editor = other_editor

    try:
        lyrics_file = Path('.') / 'lyrics.txt'
        with lyrics_file.open('wt') as f:
            f.write('\n')

        subprocess.call([
            editor,
            lyrics_file,
        ])

        print('Reading file...')
        with open('lyrics.txt', 'rt', encoding='utf-8') as f:
            result['lyrics'] = f.read().strip()
        print('Done')

    except OSError as err:
        logging.exception(err)

    cover = input('Insert an album cover? [Y/n] ')
    if cover.lower() not in ('n','н'):
        try:
            print(
                'Download the cover and enter its path:',
                '(relative path is not recommended)',
                sep='\n',
            )
            cover_file = Path(input().strip())

            with cover_file.open('rb') as f:
                result['cover'] = f.read()

            result['cover_mime'] = (
                mimetypes.guess_type(cover_file)[0]
                or 'image/jpeg'
            )
        except Exception as err:
            logging.exception(err)
    
    return result


def tagmp3(
        file: str,
        parsed: ParseResult,
        copy: bool) -> None:

    oldpath = Path(file)
    newpath = oldpath
    
    if copy:

        newdir = (
            Path('./tagged') /
            parsed['artist'] /
            parsed['album']
        )
        os.makedirs(newdir, exist_ok=True)

        newpath = newdir / (
            f"{parsed['track_no']}. " +
            f"{parsed['title']}.mp3"
        )
        shutil.copy(oldpath, newpath)

        if parsed['cover'] is not None:

            ext = mimetypes.guess_extension(
                parsed['cover_mime'] or ''
            ) or '.jpg'

            cover = newdir / f'cover{ext}'
            with cover.open('wb') as f:
                f.write(parsed['cover'])
    
    id3 = ID3(str(newpath))
    id3['TPE1'] = TPE1(text=parsed['artist'])
    id3['TIT2'] = TIT2(text=parsed['title'])
    id3['TALB'] = TALB(text=parsed['album'])
    id3['TYER'] = TYER(text=f"{parsed['year']}")
    id3['TRCK'] = TRCK(
        text=(
            f"{parsed['track_no']}/"
            f"{parsed['tracks']}"
        )
    )
    id3['USLT'] = USLT(text=parsed['lyrics'])
    if parsed['cover'] is not None:
        id3['APIC'] = APIC(
            data=parsed['cover'],
            mime=parsed['cover_mime'],
        )
    id3.save()


if __name__ == '__main__':
    main()