# -*- coding: utf-8 -*-
import sys
import os
import re
import argparse
import string
import random
from waybackpy.wrapper import Url
from waybackpy.__version__ import __version__


def _save(obj):
    return obj.save()


def _archive_url(obj):
    return obj.archive_url


def _json(obj):
    return obj.JSON


def _oldest(obj):
    return obj.oldest()


def _newest(obj):
    return obj.newest()


def _total_archives(obj):
    return obj.total_archives()


def _near(obj, args):
    _near_args = {}
    if args.year:
        _near_args["year"] = args.year
    if args.month:
        _near_args["month"] = args.month
    if args.day:
        _near_args["day"] = args.day
    if args.hour:
        _near_args["hour"] = args.hour
    if args.minute:
        _near_args["minute"] = args.minute
    return obj.near(**_near_args)


def _save_urls_on_file(input_list, live_url_count):
    m = re.search("https?://([A-Za-z_0-9.-]+).*", input_list[0])
    if m:
        domain = m.group(1)
    else:
        domain = "domain-unknown"

    uid = "".join(
        random.choice(string.ascii_lowercase + string.digits) for _ in range(6)
    )

    file_name = "%s-%d-urls-%s.txt" % (domain, live_url_count, uid)
    file_content = "\n".join(input_list)
    file_path = os.path.join(os.getcwd(), file_name)
    with open(file_path, "w+") as f:
        f.write(file_content)
    return "%s\n\n'%s' saved in current working directory" % (file_content, file_name)


def _known_urls(obj, args):
    """Abbreviations:
    sd = subdomain
    al = alive
    """
    sd = False
    al = False
    if args.subdomain:
        sd = True
    if args.alive:
        al = True
    url_list = obj.known_urls(alive=al, subdomain=sd)
    total_urls = len(url_list)

    if total_urls > 0:
        text = _save_urls_on_file(url_list, total_urls)
    else:
        text = "No known URLs found. Please try a diffrent domain!"

    return text


def _get(obj, args):
    if args.get.lower() == "url":
        return obj.get()

    if args.get.lower() == "archive_url":
        return obj.get(obj.archive_url)

    if args.get.lower() == "oldest":
        return obj.get(obj.oldest())

    if args.get.lower() == "latest" or args.get.lower() == "newest":
        return obj.get(obj.newest())

    if args.get.lower() == "save":
        return obj.get(obj.save())

    return "Use get as \"--get 'source'\", 'source' can be one of the followings: \
        \n1) url - get the source code of the url specified using --url/-u.\
        \n2) archive_url - get the source code of the newest archive for the supplied url, alias of newest.\
        \n3) oldest - get the source code of the oldest archive for the supplied url.\
        \n4) newest - get the source code of the newest archive for the supplied url.\
        \n5) save - Create a new archive and get the source code of this new archive for the supplied url."


def args_handler(args):
    if args.version:
        return "waybackpy version %s" % __version__

    if not args.url:
        return (
            "waybackpy %s \nSee 'waybackpy --help' for help using this tool."
            % __version__
        )

    if args.user_agent:
        obj = Url(args.url, args.user_agent)
    else:
        obj = Url(args.url)

    if args.save:
        return _save(obj)
    if args.archive_url:
        return _archive_url(obj)
    if args.json:
        return _json(obj)
    if args.oldest:
        return _oldest(obj)
    if args.newest:
        return _newest(obj)
    if args.known_urls:
        return _known_urls(obj, args)
    if args.total:
        return _total_archives(obj)
    if args.near:
        return _near(obj, args)
    if args.get:
        return _get(obj, args)
    message = (
        "You only specified the URL. But you also need to specify the operation."
        "\nSee 'waybackpy --help' for help using this tool."
    )
    return message


def parse_args(argv):
    parser = argparse.ArgumentParser()

    requiredArgs = parser.add_argument_group("URL argument (required)")
    requiredArgs.add_argument(
        "--url", "-u", help="URL on which Wayback machine operations would occur"
    )

    userAgentArg = parser.add_argument_group("User Agent")
    help_text = 'User agent, default user_agent is "waybackpy python package - https://github.com/akamhy/waybackpy"'
    userAgentArg.add_argument("--user_agent", "-ua", help=help_text)

    saveArg = parser.add_argument_group("Create new archive/save URL")
    saveArg.add_argument(
        "--save", "-s", action="store_true", help="Save the URL on the Wayback machine"
    )

    auArg = parser.add_argument_group("Get the latest Archive")
    auArg.add_argument(
        "--archive_url",
        "-au",
        action="store_true",
        help="Get the latest archive URL, alias for --newest",
    )

    jsonArg = parser.add_argument_group("Get the JSON data")
    jsonArg.add_argument(
        "--json",
        "-j",
        action="store_true",
        help="JSON data of the availability API request",
    )

    oldestArg = parser.add_argument_group("Oldest archive")
    oldestArg.add_argument(
        "--oldest",
        "-o",
        action="store_true",
        help="Oldest archive for the specified URL",
    )

    newestArg = parser.add_argument_group("Newest archive")
    newestArg.add_argument(
        "--newest",
        "-n",
        action="store_true",
        help="Newest archive for the specified URL",
    )

    totalArg = parser.add_argument_group("Total number of archives")
    totalArg.add_argument(
        "--total",
        "-t",
        action="store_true",
        help="Total number of archives for the specified URL",
    )

    getArg = parser.add_argument_group("Get source code")
    getArg.add_argument(
        "--get",
        "-g",
        help="Prints the source code of the supplied url. Use '--get help' for extended usage",
    )

    knownUrlArg = parser.add_argument_group(
        "URLs known and archived to Waybcak Machine for the site."
    )
    knownUrlArg.add_argument(
        "--known_urls", "-ku", action="store_true", help="URLs known for the domain."
    )
    help_text = "Use with '--known_urls' to include known URLs for subdomains."
    knownUrlArg.add_argument("--subdomain", "-sub", action="store_true", help=help_text)
    help_text = "Only include live URLs. Will not inlclude dead links."
    knownUrlArg.add_argument("--alive", "-a", action="store_true", help=help_text)

    nearArg = parser.add_argument_group("Archive close to time specified")
    nearArg.add_argument(
        "--near", "-N", action="store_true", help="Archive near specified time"
    )

    nearArgs = parser.add_argument_group("Arguments that are used only with --near")
    nearArgs.add_argument("--year", "-Y", type=int, help="Year in integer")
    nearArgs.add_argument("--month", "-M", type=int, help="Month in integer")
    nearArgs.add_argument("--day", "-D", type=int, help="Day in integer.")
    nearArgs.add_argument("--hour", "-H", type=int, help="Hour in intege")
    nearArgs.add_argument("--minute", "-MIN", type=int, help="Minute in integer")

    parser.add_argument(
        "--version", "-v", action="store_true", help="Waybackpy version"
    )

    return parser.parse_args(argv[1:])


def main(argv=None):
    if argv is None:
        argv = sys.argv
    args = parse_args(argv)
    output = args_handler(args)
    print(output)


if __name__ == "__main__":
    sys.exit(main(sys.argv))
