from flask import Flask
from flask_cors import CORS
from pyquery import PyQuery as pq
from lxml import etree
from pynimeapi import PyNime

import requests
import traceback
import json
from bs4 import BeautifulSoup

app = Flask(__name__)
CORS(app)
endpoint = 'https://anitaku.to/'

@app.route("/")
def hello_world():
    return "Hello, World!"

@app.route("/home")
def home():
    try:

        response = requests.get(endpoint+"home.html")
        soup = BeautifulSoup(response.content, "html.parser")
        new_episodes = soup.find("div", {"class": "main_body"}).find("div", {"class": "last_episodes"}).find("ul", {"class": "items"})
        new_episodes = new_episodes.find_all("li")

        new_episodes_list = []
        for new_episode in new_episodes:  # For every anime found
            name = new_episode.find("p").find("a").text
            img = new_episode.find('div').find('a').find('img')['src']
            link = new_episode.find('div').find('a')['href']
            episode_id = link[1:len(link)]

            anime_obj = { 
                "name": name, 
                "img_url": img, 
                "episode_id": episode_id,
                "anime_id":episode_id.split('-episode-')[0],
                "episode_num":episode_id.split('-episode-')[1]
            }
           
            new_episodes_list.append(anime_obj)

        result = {"new_episodes":new_episodes_list,"popular":popular(1)}
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    
@app.route("/Popular/<pagenum>")

def popular(pagenum):
    try:

        response = requests.get(endpoint+"popular.html?page="+str(pagenum))
        soup = BeautifulSoup(response.content, "html.parser")
        anime_list = []

        popular_episodes = soup.find("div", {"class": "main_body"}).find("div", {"class": "last_episodes"}).find("ul", {"class": "items"})
        popular_episodes = popular_episodes.find_all("li")
        for popular_episode in popular_episodes:  # For every anime found
            name = popular_episode.find("p").find("a").text
            img = popular_episode.find('div').find('a').find('img')['src']
            link = popular_episode.find('div').find('a')['href']
            anime_id = link[10:len(link)]

            anime_obj = { 
                "name": name, 
                "img_url": img, 
                "anime_id": anime_id
            }
           
            anime_list.append(anime_obj)

        total_pages = soup.find("div", {"class": "main_body"}).find("div", {"class": "anime_name_pagination"})
        total_pages = total_pages.find("div", {"class": "pagination"}).find("ul", {"class": "pagination-list"})
        total_pages = total_pages.find_all("li")
        no_of_pages = 1

        last_div = None
        for last_div in total_pages:pass
        if last_div:
            no_of_pages = last_div.getText()

        result = {"data":anime_list,"total_pages":no_of_pages}
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    

   
@app.route("/NewSeasons/<pagenum>")

def newSeason(pagenum):
    try:

        response = requests.get(endpoint+"new-season.html?page="+str(pagenum))
        soup = BeautifulSoup(response.content, "html.parser")
        anime_list = []

        popular_episodes = soup.find("div", {"class": "main_body"}).find("div", {"class": "last_episodes"}).find("ul", {"class": "items"})
        popular_episodes = popular_episodes.find_all("li")
        for popular_episode in popular_episodes:  # For every anime found
            name = popular_episode.find("p").find("a").text
            img = popular_episode.find('div').find('a').find('img')['src']
            link = popular_episode.find('div').find('a')['href']
            anime_id = link[10:len(link)]

            anime_obj = { 
                "name": name, 
                "img_url": img, 
                "anime_id": anime_id
            }
           
            anime_list.append(anime_obj)

        total_pages = soup.find("div", {"class": "main_body"}).find("div", {"class": "anime_name_pagination"})
        total_pages = total_pages.find("div", {"class": "pagination"}).find("ul", {"class": "pagination-list"})
        total_pages = total_pages.find_all("li")
        no_of_pages = 1

        last_div = None
        for last_div in total_pages:pass
        if last_div:
            no_of_pages = last_div.getText()

        result = {"data":anime_list,"total_pages":no_of_pages}
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    
      
@app.route("/NewEpisodes/<pagenum>")

def newEpisodes(pagenum):
    try:

        response = requests.get(endpoint+"home.html?page="+str(pagenum))
        soup = BeautifulSoup(response.content, "html.parser")
        anime_list = []

        popular_episodes = soup.find("div", {"class": "main_body"}).find("div", {"class": "last_episodes"}).find("ul", {"class": "items"})
        popular_episodes = popular_episodes.find_all("li")
        for popular_episode in popular_episodes:  # For every anime found
            name = popular_episode.find("p").find("a").text
            img = popular_episode.find('div').find('a').find('img')['src']
            link = popular_episode.find('div').find('a')['href']
            episode_id = link[1:len(link)]

            anime_obj = { 
                "name": name, 
                "img_url": img,
                "episode_id": episode_id,
                "anime_id":episode_id.split('-episode-')[0],
                "episode_num":episode_id.split('-episode-')[1]
            }
           
            anime_list.append(anime_obj)

        total_pages = soup.find("div", {"class": "main_body"}).find("div", {"class": "anime_name_pagination"})
        total_pages = total_pages.find("div", {"class": "pagination"}).find("ul", {"class": "pagination-list"})
        total_pages = total_pages.find_all("li")
        no_of_pages = 1

        last_div = None
        for last_div in total_pages:pass
        if last_div:
            no_of_pages = last_div.getText()

        result = {"data":anime_list,"total_pages":no_of_pages}
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    
    
      
@app.route("/GetMovies/<alphabet>/<pagenum>")

def getMovies(alphabet,pagenum):
    try:
        if alphabet == "ALL":
            alphabet = ''

        filter_by = "?aph="+str(alphabet)+"&page="+str(pagenum)
        response = requests.get(endpoint+"anime-movies.html"+filter_by)
        soup = BeautifulSoup(response.content, "html.parser")
        anime_list = []

        popular_episodes = soup.find("div", {"class": "main_body"}).find("div", {"class": "last_episodes"}).find("ul", {"class": "items"})
        popular_episodes = popular_episodes.find_all("li")
        for popular_episode in popular_episodes:  # For every anime found
            name = popular_episode.find("p").find("a").text
            img = popular_episode.find('div').find('a').find('img')['src']
            link = popular_episode.find('div').find('a')['href']

            anime_obj = { 
                "name": name, 
                "img_url": img,
                "anime_id":link.replace('/category/','')
            }
           
            anime_list.append(anime_obj)

        total_pages = soup.find("div", {"class": "main_body"}).find("div", {"class": "anime_name_pagination"})
        total_pages = total_pages.find("div", {"class": "pagination"}).find("ul", {"class": "pagination-list"})
        total_pages = total_pages.find_all("li")
        no_of_pages = 1

        last_div = None
        for last_div in total_pages:pass
        if last_div:
            no_of_pages = last_div.getText()

        result = {"data":anime_list,"total_pages":no_of_pages}
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    

      
@app.route("/GetAnimeList/<alphabet>/<pagenum>")

def getAnimeList(alphabet,pagenum):
    try:

        if alphabet == "ALL":
            alphabet = ''

        filter_by = "?aph="+str(alphabet)+"&page="+str(pagenum)
        response = requests.get(endpoint+"anime-movies.html"+filter_by)
        soup = BeautifulSoup(response.content, "html.parser")
        anime_list = []

        popular_episodes = soup.find("div", {"class": "main_body"}).find("div", {"class": "last_episodes"}).find("ul", {"class": "items"})
        popular_episodes = popular_episodes.find_all("li")
        for popular_episode in popular_episodes:  # For every anime found
            name = popular_episode.find("p").find("a").text
            img = popular_episode.find('div').find('a').find('img')['src']
            link = popular_episode.find('div').find('a')['href']

            anime_obj = { 
                "name": name, 
                "img_url": img,
                "anime_id":link.replace('/category/','')
            }
           
            anime_list.append(anime_obj)

        total_pages = soup.find("div", {"class": "main_body"}).find("div", {"class": "anime_name_pagination"})
        total_pages = total_pages.find("div", {"class": "pagination"}).find("ul", {"class": "pagination-list"})
        total_pages = total_pages.find_all("li")
        no_of_pages = 1

        last_div = None
        for last_div in total_pages:pass
        if last_div:
            no_of_pages = last_div.getText()

        result = {"data":anime_list,"total_pages":no_of_pages}
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    

@app.route("/search/<query>")

def search(query):
    try:

        response = requests.get(endpoint+"/search.html?keyword="+str(query))
        soup = BeautifulSoup(response.content, "html.parser")
        anime_list = []

        popular_episodes = soup.find("div", {"class": "main_body"}).find("div", {"class": "last_episodes"}).find("ul", {"class": "items"})
        popular_episodes = popular_episodes.find_all("li")
        for popular_episode in popular_episodes:  # For every anime found
            name = popular_episode.find("p").find("a").text
            img = popular_episode.find('div').find('a').find('img')['src']
            link = popular_episode.find('div').find('a')['href']
            anime_id = link[10:len(link)]

            anime_obj = { 
                "name": name, 
                "img_url": img,
                "anime_id": anime_id
            }
           
            anime_list.append(anime_obj)

        result = anime_list
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    
    
@app.route("/getAnime/<anime_id>")

def anime(anime_id):
    try:

        try:
            response = requests.get(endpoint+"category/"+str(anime_id))
        
        except:
            response = requests.get(endpoint+"/"+str(anime_id))
        
        html = response.content
        result = getAnimeInfo(html,anime_id)
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    


def getAnimeInfo(html,anime_id):
    try:
        d = pq(html)
        
        anime_id = anime_id or 0
        img_url = d('div.anime_info_body_bg  img').attr('src')
        anime_name = d('div.anime_info_body_bg  h1').text()
        if(len(anime_name) == 0):
            anime_name = d('div.anime-info a').text()
            anime_id = d('div.anime-info a').attr('href')
            anime_id = anime_id.replace('/category/','')
        
        anime_about = d('div.main_body  div:nth-child(2) > div.anime_info_body_bg > p:nth-child(5)').text()
        genre = d('div.main_body  div:nth-child(2) > div.anime_info_body_bg > p:nth-child(7) a').text()

        type = d('div.main_body  div:nth-child(2) > div.anime_info_body_bg > p:nth-child(4) a').text()
        date_aired = d('div.main_body  div:nth-child(2) > div.anime_info_body_bg > p:nth-child(8)').text()
        status = d('div.main_body  div:nth-child(2) > div.anime_info_body_bg > p:nth-child(9) a').text()
        # # add the new code here
        ep_start = 1
        ep_end = d('#episode_page li:last').find('a').attr('ep_end')

        id = d("input#movie_id").val()
        
        alias = d("input#alias_anime").val()

        ep_obj = {
            "ep_start":ep_start,
            "ep_end":ep_end,
            "id":id,
            "alias":alias,
        }

        
        anime_result = { 
            'anime_id':anime_id,
            'name': anime_name, 
            'img_url': img_url, 
            'about': anime_about, 
            'episode_id': getEpisodeInfo(ep_obj),
            'type':type,
            'date_aired':date_aired,
            'status':status,
            'genre':str(genre)
        }

        return anime_result
        
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    

    
def getEpisodeInfo(obj):
    try:

        result = []
        ep_start = obj.get('ep_start')
        ep_end = obj.get('ep_end')
        id = obj.get('id')
        episode_id = obj.get('alias')
        request_url = "https://ajax.gogocdn.net/ajax/load-list-episode?ep_start="+str(ep_start)+"&ep_end="+str(ep_end)+"&id="+str(id)+"&alias="+str(episode_id)
        response = requests.get(request_url)
        soup = BeautifulSoup(response.content, "html.parser")
        episodes = soup.find("ul", {"id": "episode_related"}).find_all("li")
        
        for episode in episodes:  # For every anime found
            ep_num = episode.find('a')['href']
            ep_num = ep_num.replace("/", '')
            ep_num = ep_num.strip()
           
            result.append(ep_num)

        result = result[0:len(result)][::-1]
       
        return result
    
    except AttributeError:
        return {"status":"400", "reason":traceback.print_exc()}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}
    
       
@app.route("/getEpisode/<episode_id>")

def watchAnime(episode_id):
    try:

        result = {}
        api = PyNime(endpoint)
        stream_urls = api.get_stream_urls(endpoint+"/"+str(episode_id))

        get_anime_info = requests.get(endpoint+"/"+str(episode_id))
        
        html = get_anime_info.content
        anime_info = getAnimeInfo(html,episode_id)

        sources = []
        sources_bk = []
        source = {}

        if stream_urls.get('1080'):
            source["file"] = stream_urls["1080"]
            source["label"] = "hls P"
            source["type"] = "hls"
            sources.append(source)

        if stream_urls.get('720'):
            source["file"] = stream_urls["720"]
            source["label"] = "hls P"
            source["type"] = "hls"
            sources_bk.append(source)

        if stream_urls.get('480'): 
            source["file"] = stream_urls["480"]
            source["label"] = "hls P"
            source["type"] = "hls"
            sources_bk.append(source)

        if stream_urls.get('360'):
            source["file"] = stream_urls["360"]
            source["label"] = "hls P"
            source["type"] = "hls"
            sources_bk.append(source)



        result["anime_info"] = anime_info
        result["sources"] = sources
        result["sources_bk"] = sources_bk
        
        return result
    
    except AttributeError:
        return {"status":"400", "reason":"Invalid animeid"}
    except requests.exceptions.ConnectionError:
        return {"status":"404", "reason":"Check the host's network Connection"}