DaumMovie

# -*- coding: utf-8 -*-
# Daum Movie

import urllib
import urlparse
import unicodedata

DAUM_MOVIE_SRCH = "movie_search.php?name=%s"
DAUM_MOVIE_DETAIL = "movie_detail.php?id=%s"
DAUM_MOVIE_CAST = "movie_cast.php?id=%s"
DAUM_MOVIE_PHOTO = "movie_photo.php?id=%s"

DAUM_TV_SRCH = "tv_search.php?name=%s"
DAUM_TV_DETAIL = "tv_detail.php?id=%s"
DAUM_TV_CAST = "tv_cast.php?id=%s"
DAUM_TV_EPISODE = "tv_episode.php?id=%s"

JSON_MAX_SIZE = 10 * 1024 * 1024

DAUM_CR_TO_MPAA_CR = {
    u'전체관람가': {
        'KMRB': 'kr/A',
        'MPAA': 'G'
    },
    u'12세이상관람가': {
        'KMRB': 'kr/12',
        'MPAA': 'PG'
    },
    u'15세이상관람가': {
        'KMRB': 'kr/15',
        'MPAA': 'PG-13'
    },
    u'청소년관람불가': {
        'KMRB': 'kr/R',
        'MPAA': 'R'
    },
    u'제한상영가': {     # 어느 여름날 밤에 (2016)
        'KMRB': 'kr/X',
        'MPAA': 'NC-17'
    }
}


def Start():
    HTTP.CacheTime = CACHE_1HOUR * 12
    HTTP.Headers['Accept'] = 'text/html, application/json'


####################################################################################################
def to_int(value):
    try:
        return int(value)
    except ValueError:
        return 0


def get_json_data(url):
    try:
        base_url = Prefs['base_url']
        url = urlparse.urljoin(base_url, url)
        json = JSON.ObjectFromURL(url=url, max_size=JSON_MAX_SIZE)
    except:
        Log("Can't get JSON, url=%s" % url)
        return None

    if 'error' in json:
        Log('JSON is error, url=%s, errorMsg=%s' % (url, json['error']))
        return None

    if not json or 'data' not in json:
        Log("JSON is empty, url=%s" % url)
        return False

    return json['data']


def update_photo(metadata, url):
    max_poster = int(Prefs['max_num_posters'])
    max_art = int(Prefs['max_num_arts'])
    poster_count = 0
    art_count = 0

    data = get_json_data(url)
    if not data:
        return False

    for photo_url in data['posters']:
        if poster_count >= max_poster:
            break

        try:
            metadata.posters[photo_url] = Proxy.Preview(HTTP.Request(photo_url), sort_order=poster_count)
            poster_count += 1
        except:
            pass

    for photo_url in data['arts']:
        if art_count >= max_art:
            break

        try:
            metadata.art[photo_url] = Proxy.Preview(HTTP.Request(photo_url), sort_order=art_count)
            art_count += 1
        except:
            pass

    Log('Total %d posters, %d artworks' % (poster_count, art_count))

    return bool(poster_count)


def update_cast(cast_list, metadata):
    if not cast_list:
        return

    metadata.clear()
    for cast in cast_list:
        new_metadata = metadata.new()
        if 'role' in cast:
            new_metadata.role = cast['role']

        if 'name' in cast:
            new_metadata.name = cast['name']

        if 'photo' in cast:
            new_metadata.photo = cast['photo']


def search_daum_movie(results, media, lang):
    media_name = media.name
    media_name = unicodedata.normalize('NFKC', unicode(media_name)).strip()
    Log("search: %s %s" % (media_name, media.year))

    url = DAUM_MOVIE_SRCH % urllib.quote(media_name.encode('utf8'))
    search_data = get_json_data(url)
    if not search_data:
        return

    media_year = to_int(media.year)
    for item in search_data:
        year = str(item['year'])
        id = str(item['id'])
        title = item['title']
        year_diff = abs(media_year - to_int(year))
        match_title = title == media_name

        if len(search_data) == 1:
            score = 80
        else:
            if year_diff == 0:
                score = 95 if match_title else 75
            elif year_diff == 1:
                score = 90 if match_title else 70
            else:
                score = 15 if match_title else 10

        Log('ID=%s, media_name=%s, title=%s, year=%s, score=%d' % (id, media_name, title, year, score))
        results.Append(MetadataSearchResult(id=id, name=title, year=year, score=score, lang=lang))


def update_daum_movie(metadata):
    # (1) from detail page
    url = DAUM_MOVIE_DETAIL % metadata.id
    data = get_json_data(url)
    if not data:
        return

    cr_key = 'MPAA' if Prefs['use_mpaa'] else 'KMRB'
    metadata.title = data['title']
    metadata.year = int(data['year'])
    metadata.original_title = data['original_title']
    metadata.rating = float(data['rating'])
    metadata.tagline = data['tagline']
    metadata.genres.clear()
    for genre in data['genres']:
        metadata.genres.add(genre)
    metadata.countries.clear()
    for country in data['countries']:
        metadata.countries.add(country)
    if data['originally_available_at']:
        metadata.originally_available_at = Datetime.ParseDate(data['originally_available_at']).date()
    metadata.duration = int(data['duration'])
    if data['content_rating']:
        cr = data['content_rating']
        match = Regex(u'미국 (.*) 등급').search(cr)
        if match:
            metadata.content_rating = match.group(1)
        elif cr in DAUM_CR_TO_MPAA_CR:
            metadata.content_rating = DAUM_CR_TO_MPAA_CR[cr][cr_key]
        else:
            metadata.content_rating = 'kr/' + cr
    metadata.summary = data['summary']
    poster_url = data['poster_url']

    # (2) cast crew
    url = DAUM_MOVIE_CAST % metadata.id
    cast_data = get_json_data(url)
    if cast_data:
        update_cast(cast_data['directors'], metadata.directors)
        update_cast(cast_data['producers'], metadata.producers)
        update_cast(cast_data['writers'], metadata.writers)
        update_cast(cast_data['roles'], metadata.roles)

    # (3) from photo page
    if not update_photo(metadata, DAUM_MOVIE_PHOTO % metadata.id) and poster_url:
        try:
            poster = HTTP.Request(poster_url)
            metadata.posters[poster_url] = Proxy.Media(poster)
        except:
            pass


def search_daum_tv(results, media, lang):
    media_name = media.show
    media_name = unicodedata.normalize('NFKC', unicode(media_name)).strip()
    Log("search: %s %s" % (media_name, media.year))

    url = DAUM_TV_SRCH % (urllib.quote(media_name.encode('utf8')))
    search_data = get_json_data(url)
    if not search_data:
        return

    for item in search_data:
        year = str(item['year'])
        id = str(item['id'])
        title = item['title']
        if year == media.year:
            score = 95
        elif len(search_data) == 1:
            score = 80
        else:
            score = 10

        Log('ID=%s, media_name=%s, title=%s, year=%s, score=%d' % (id, media_name, title, year, score))
        results.Append(MetadataSearchResult(id=id, name=title, year=year, score=score, lang=lang))


def update_daum_tv(metadata):
    # (1) from detail page
    url = DAUM_TV_DETAIL % metadata.id
    data = get_json_data(url)
    if not data:
        return

    metadata.title = data['title']
    metadata.original_title = data['original_title']
    metadata.rating = float(data['rating'])
    metadata.genres.clear()
    for genre in data['genres']:
        metadata.genres.add(genre)
    if data['originally_available_at']:
        metadata.originally_available_at = Datetime.ParseDate(data['originally_available_at']).date()
    metadata.summary = data['summary']
    poster_url = data['poster_url']
    if poster_url:
        try:
            poster = HTTP.Request(poster_url)
            metadata.posters[poster_url] = Proxy.Media(poster)
        except:
            pass

    # (2) cast crew
    url = DAUM_TV_CAST % metadata.id
    cast_data = get_json_data(url)
    if not cast_data:
        cast_data = {
            'roles': [],
            'directors': [],
            'producers': [],
            'writers': [],
        }

    update_cast(cast_data['roles'], metadata.roles)

    # (3) from episode page
    url = DAUM_TV_EPISODE % metadata.id
    episode_data = get_json_data(url)
    if not episode_data:
        return

    for item in episode_data:
        episode = metadata.seasons[item['seasons']].episodes[item['episodes']]
        episode.title = item['title']
        episode.summary = item['summary']
        if item['originally_available_at']:
            episode.originally_available_at = Datetime.ParseDate(item['originally_available_at'], '%Y%m%d').date()
        episode.rating = float(item['rating'])

        update_cast(cast_data['directors'], episode.directors)
        update_cast(cast_data['producers'], episode.producers)
        update_cast(cast_data['writers'], episode.writers)


####################################################################################################
class DaumMovieAgent(Agent.Movies):
    name = "Daum Movie"
    primary_provider = True
    languages = [Locale.Language.Korean]
    accepts_from = ['com.plexapp.agents.localmedia']

    def search(self, results, media, lang, manual=False):
        return search_daum_movie(results, media, lang)

    def update(self, metadata, media, lang):
        update_daum_movie(metadata)


class DaumMovieTvAgent(Agent.TV_Shows):
    name = "Daum Movie"
    primary_provider = True
    languages = [Locale.Language.Korean]
    accepts_from = ['com.plexapp.agents.localmedia']

    def search(self, results, media, lang, manual=False):
        return search_daum_tv(results, media, lang)

    def update(self, metadata, media, lang):
        update_daum_tv(metadata)