from transformers import pipeline
from bs4 import BeautifulSoup
import requests
import urllib
import json
import argparse
from pathlib import Path
import os

from controlnet_aux.processor import Processor
from colorthief import ColorThief
from colors import name_that_color, rgb_to_hex, NTC_NAMES, CSS3_NAMES

from PIL import Image


class Scraper(object):
    def __init__(self, urls):
        self.urls = urls

    def fetch(self, url):
        return requests.get(url, headers={"User-Agent": "Mozilla/5.0"})

    def parse(self, text):
        return BeautifulSoup(text, 'html.parser')

    def download_image(self, url, path):
        image = requests.get(url)
        open(path, 'wb').write(image.content)


class GraffitiDatabaseScraper(Scraper):
    def __init__(self):
        Scraper.__init__(self, ["https://graffiti-database.com"])

    def get_image_urls(self, parsed):
        pages = parsed.select('.image-info a')
        image_urls = []
        for page in pages:
            image_urls.append(page.get('href'))
        return image_urls

    def scrape_image(self, url):
        print("Scraping image page {0}".format(url))

        fetched = self.fetch(url)

        if fetched.status_code != 200:
            raise "Scraping image page did fail"

        text = fetched.text
        parsed = self.parse(text)

        image = parsed.select('.img-fluid')[0].get('src')

        tag_links = parsed.select('a.tag')

        url_parts = urllib.parse.unquote(
            urllib.parse.unquote(url)).rsplit("/", 2)
        artist = url_parts[1]
        return {
            "image_url": image,
            "city": tag_links[-1].get_text().strip(),
            "artist": artist if artist != "Writer Unknown" and artist != "Writers Unknown" else None
        }

    def scrape_page(self, url):
        print("Scraping page {0}".format(url))

        text = self.fetch(url).text
        parsed = self.parse(text)

        image_urls = self.get_image_urls(parsed)

        if len(image_urls) == 0:
            return False

        for image_url in image_urls:
            try:
                result = self.scrape_image(
                    "https://graffiti-database.com" + image_url)
            except:
                continue

            file_name = result["image_url"].split('/')[-1]

            self.download_image(result["image_url"],
                                './images/' + file_name)

            result["file"] = file_name

            with open('./images/' + file_name + '.json', 'w', encoding='utf-8') as f:
                f.write(json.dumps(result, indent=2, ensure_ascii=False))

        return True

    def scrape(self):
        url = self.urls[0]
        print("Scraping {0}".format(
            url))

        count = 1
        has_images = True
        while has_images:
            has_images = self.scrape_page(url + "?page=" + str(count))
            count += 1


class GraffitiScraper(Scraper):
    def __init__(self):
        Scraper.__init__(self, ["https://www.graffiti.org/index/world.html",
                                "https://www.graffiti.org/index/europe.html", "https://www.graffiti.org/index/usa.html"])

    def scrape_page(self, url, city_name):
        print("Scraping page {0}".format(url))

        text = self.fetch(url).text
        parsed = self.parse(text)

        image_elements = parsed.select('a[href*=".jpg"]')

        for image_element in image_elements:
            if image_element.get_text().strip() == "":
                tags = image_element.find_next_sibling(string=True).get_text(
                ).strip() if image_element.find_next_sibling(string=True) else ""
            else:
                continue
            image_url = image_element.get("href").replace("/", "_")
            url_parts = url.split('/')
            url_parts[-1] = image_element.get("href")
            self.download_image("/".join(url_parts),
                                './images/' + image_url)

            with open('./images/' + image_url + '.json', 'w', encoding='utf-8') as f:
                f.write(json.dumps({
                    "file": image_url,
                    "image_url": "/".join(url_parts),
                    "artist": tags,
                    "city": city_name if city_name != "Various cities" else None
                }, indent=2, ensure_ascii=False))

    def scrape_url(self, url):
        print("Scraping url {0}".format(url))

        text = self.fetch(url).text
        parsed = self.parse(text)

        cities = parsed.find_all("h4")

        for city in cities:
            city_name = city.get_text().split("\n")[0].strip()
            pages = city.find_all("a")
            for page in pages:
                if page.get_text().strip() == "§":
                    continue
                self.scrape_page(
                    "https://www.graffiti.org/index/" + page.get("href"), city_name)

    def scrape(self):
        for url in self.urls:
            self.scrape_url(url)


class CLI():
    def __init__(self):
        parser = argparse.ArgumentParser(
            prog='graffiti-cli',
            description='Tools for setting up the dataset')
        subparsers = parser.add_subparsers(dest="command", required=True)

        scrape = subparsers.add_parser(
            'scrape', help='Scrapes data sources and downloads images')
        scrape.add_argument('--source',
                            default='graffiti.org',
                            choices=['graffiti.org', 'graffiti-database.com'],
                            help='Choose data source to scrape')
        subparsers.add_parser('cleanup', help='Cleans up downloaded images')
        subparsers.add_parser('caption', help='Captions downloaded images')
        subparsers.add_parser('palette', help='Creates color palettes for downloaded images')
        subparsers.add_parser('condition', help='Condition downloaded images')
        metadata = subparsers.add_parser('metadata', help='Creates single meta files from metadata.jsonl')
        metadata.add_argument('--source',
                            default='graffiti.org',
                            choices=['graffiti.org', 'graffiti-database.com'],
                            help='Choose data source to use')

        args = parser.parse_args()
        if args.command == 'scrape':
            if args.source == 'graffiti.org':
                GraffitiScraper().scrape()
            elif args.source == 'graffiti-database.com':
                GraffitiDatabaseScraper().scrape()
        elif args.command == 'cleanup':
            path = Path("./images").rglob("*.jpg")
            for i, img_p in enumerate(path):
                try:
                    Image.open(img_p).load()
                except Exception:
                    path_name = str(img_p)
                    print(path_name + " is broken. Deleting!")
                    os.remove(path_name)
                    os.remove(path_name + ".json")
        elif args.command == 'caption':
            captioner = pipeline(
                "image-to-text", model="Salesforce/blip-image-captioning-base")
            path = Path("./images").rglob("*.jpg")
            count = len(list(Path("./images").rglob("*.jpg")))
            for i, img_p in enumerate(path):
                path_name = str(img_p)
                with open(path_name + ".json", 'r+', encoding='utf-8') as f:
                    data = json.load(f)

                    f.seek(0)

                    caption = captioner(path_name)[0]["generated_text"]

                    if "album" in caption:
                        caption = "a wall with graffiti on it"

                    json.dump({
                        "file": data["file"],
                        "image_url": data["image_url"],
                        "artist": data["artist"],
                        "city": data["city"],
                        "caption": caption
                    }, f, indent=2)
                    f.truncate()

                    print("{0} / {1}".format(i + 1, count), path_name, caption)
        elif args.command == 'palette':
            path = Path("./images").rglob("*.jpg")
            count = len(list(Path("./images").rglob("*.jpg")))
            for i, img_p in enumerate(path):
                path_name = str(img_p)
                with open(path_name + ".json", 'r+', encoding='utf-8') as f:
                    data = json.load(f)

                    f.seek(0)

                    color_thief = ColorThief(path_name)

                    palette = []
                    for color in color_thief.get_palette(color_count=6):
                        color_hex = rgb_to_hex(color)
                        palette.append([color_hex, name_that_color(color_hex, NTC_NAMES), name_that_color(color_hex, CSS3_NAMES)])


                    json.dump({
                        "file": data["file"],
                        "image_url": data["image_url"],
                        "artist": data["artist"],
                        "city": data["city"],
                        "caption": data["caption"],
                        "palette": palette
                    }, f, indent=2)
                    f.truncate()

                    print("{0} / {1}".format(i + 1, count), path_name, palette)
        elif args.command == 'metadata':
            with open("data/" + args.source + "/metadata.jsonl", encoding="utf-8") as f:
                for row in f:
                    data = json.loads(row)
                    with open('./images/' + data["file"] + '.json', 'w') as j:
                        j.write(json.dumps(data, indent=2, ensure_ascii=False))
        elif args.command == 'conditioning':
            processor_id = 'softedge_hed'
            processor = Processor(processor_id)

            path = Path("./images").rglob("*.jpg")
            count = len(list(Path("./images").rglob("*.jpg")))
            for i, img_p in enumerate(path):
                path_name = str(img_p)
                output_path = path_name.replace("images/", "conditioning/")
                img = Image.open(img_p).convert("RGB")

                processed_image = processor(img, to_pil=True)
                processed_image.save(output_path)

                print("{0} / {1}".format(i + 1, count), path_name, output_path)

def main():
    CLI()


if __name__ == "__main__":
    main()