import os
import argparse
from datetime import datetime
import shlex
import subprocess
import tarfile
from time import sleep
from urllib.request import urlopen, Request, ProxyHandler, build_opener
import zipfile
from bs4 import BeautifulSoup as soup
from pypdl import Pypdl
from tqdm import tqdm

is_verbose = False
def vprint(*values: object, sep: str | None = " ", end: str | None = "\n", file = None, flush: bool=False):
    if is_verbose:
        print(*values, sep=sep, end=end, file=file, flush=flush)
    

def get_url_opener():
    # Read proxy from environment variables if they exist
    http_proxy = os.getenv('HTTP_PROXY')
    https_proxy = os.getenv('HTTPS_PROXY')
    proxy_dict = {}
    if http_proxy:
        proxy_dict['http'] = http_proxy
    if https_proxy:
        proxy_dict['https'] = https_proxy
    
    # Check if any proxies were set
    if proxy_dict:
        # Create a ProxyHandler with the proxy settings
        proxy_handler = ProxyHandler(proxy_dict)
        opener = build_opener(proxy_handler)
    else:
        # Use the default opener if no proxies are set
        opener = build_opener()
    return opener

#  scrape_uspto modified from https://github.com/learningmatter-mit/PatentChem/blob/main/download.py (MIT License Copyright (c) 2022 Kevin Greenman)
def scrape_uspto(patent_year):
    # Define the USPTO web page according to the year:
    patent_url = f"https://bulkdata.uspto.gov/data/patent/grant/redbook/{patent_year}/" # xiegeo: added ending slash to avoid redirect/disconnect'
    
    print(f"Scraping {patent_url} for patent files")

    # Open a connection and download the webpage:
    uClient = get_url_opener().open(Request(patent_url))

    # Read the html of the page:
    page_html = uClient.read()

    # Close the webpage:
    uClient.close()

    # Parse the html using Beautiful Soup:
    page_soup = soup(page_html, "html.parser")

    # Get all the attributes of the page, containing the link to the weekly patent files
    patent_weekly_releases = page_soup.findAll("a")

    # Here, the link are selected from containers (ex: 'I20180102.tar').
    # They can be used to complete the url for download, e.g.
    # https://bulkdata.uspto.gov/data/patent/grant/redbook/2018/I20180102.tar
    patent_link = []
    for release in patent_weekly_releases:
        match = [s for s in release if ".tar" in s]
        matchzip = [s for s in release if ((".zip" in s) or (".ZIP" in s))]
        if match != []:
            if (match[0].endswith(".tar")
                and ("testData" not in match[0])
            ):
                patent_link.append(match)
        if matchzip != []:
            if (
                matchzip[0].lower().endswith(".zip")
                and ("SUPP" not in matchzip[0])
                and ("Grant" not in matchzip[0]) 
                and ("Red Book Viewer Public" not in matchzip[0])
                and ("Sample" not in matchzip[0])
            ):
                patent_link.append(matchzip)
                
    patent_link = [link[0] for link in patent_link] # flatten list
    # remove duplicates with _r1
    all_links = patent_link
    for link in all_links:
        #print(link)
        if "_r1" in link:
            remove = link.replace("_r1", "")
            #print(f"Removing {remove} from {all_links}")
            patent_link.remove(remove)

    print(f"Found {len(patent_link)} releases from {patent_year}")
    
    # xiegeo: added assertion to make sure we have the right weekly links
    if len(patent_link) != 52 and len(patent_link) != 53 and patent_year != str(datetime.now().year):
        print(patent_weekly_releases, patent_link)
        raise ValueError(
            f"Error: Found {len(patent_link)} releases in {patent_year}, expected 52 or 53"
        )
    patent_link = [patent_url + link for link in patent_link]
    return patent_link

# class DownloadProgressBar(tqdm):
#     # Progression bar for the download
#     def update_to(self, b=1, bsize=1, tsize=None):
#         if tsize is not None:
#             self.total = tsize
#         self.update(b * bsize - self.n)

# def download_url(url, output_path):
#     with DownloadProgressBar(unit="B", unit_scale=True, miniters=1, desc=url.split("/")[-1]) as t:
#         urllib.request.urlretrieve(url, filename=output_path, reporthook=t.update_to)
# end of copied code

def download_url(url, output_path):
    if os.path.exists(output_path) and os.path.getsize(output_path) != 0: # there is a case where the output file is created but not written to by Pypdl
        print(f"Skipping download_url {output_path}, already exists")
        return
    #wget.download(url, out=output_path)
    Pypdl().start(url=url, file_path=output_path, segments=5, retries=5, clear_terminal=False)
    

def extract_all(ref, folder_name):
    if type(ref) == str:
        file_type = ref.split(".")[1].upper()
        if file_type == "ZIP":
            with zipfile.ZipFile(ref, 'r') as zip_ref:
                extract_all(zip_ref, folder_name)
        elif file_type == "TAR":
            with tarfile.open(ref, 'r') as tar_ref:
                extract_all(tar_ref, folder_name)
        else:
            raise ValueError(f"Unsupported file {ref}")
        return
    if type(ref) == zipfile.ZipFile:
        members = ref.infolist()
    elif type(ref) == tarfile.TarFile:
        members = ref.getmembers()
    else:
        raise ValueError(f"Unsupported file type {type(ref)}")
    for member in tqdm(members, desc=f"Extracting {folder_name}", unit="file"):
        ref.extract(member, folder_name)

def extract_link(link):
    packed_file = link.split("/")[-1]
    folder_name = packed_file.split(".")[0]
    #print(f"Downloading {link}")
    download_url(link, link.split("/")[-1])
    extract_all(packed_file, folder_name)
    return folder_name
    #if os.path.exists(folder_name): # there might be partial extraction of file, use this only to speed up debugging
    #    print(f"Skipping extract_link {folder_name}, already exists")
    #    return folder_name
    file_type = ref.split(".")[1].upper()
    if file_type == "ZIP":
        with zipfile.ZipFile(packed_file, 'r') as zip_ref:
            zip_ref.extractall(folder_name)
    elif file_type == "TAR":
        with tarfile.open(packed_file, 'r') as tar_ref:
            tar_ref.extractall(folder_name)
    return folder_name

def remove_unwanted_files(root_path):
    keep_zip_count = 0
    remove_zip_count = 0
    keep_mol_count = 0
    progress_bar = tqdm(desc="Removing unwanted files", unit="file")
    for subdir, dirs, files in os.walk(root_path):
        for file in files:
            progress_bar.update(1)
            if file.upper().endswith('.ZIP'):
                vprint(f"Processing zip file: {file}")
                zip_file_path = os.path.join(subdir, file)
                found_mol_files = False
                with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
                    for zip_info in zip_ref.infolist():
                        if zip_info.filename.endswith('.MOL'):
                            found_mol_files = True
                            keep_mol_count += 1
                if found_mol_files:
                    keep_zip_count += 1
                else:
                    vprint(f"No mol files found in {zip_file_path}, delete it!")
                    remove_zip_count += 1
                    #print(zip_ref.infolist())
                    try:
                        os.remove(zip_file_path)
                    except Exception as e: 
                        print(f"Error deleting {zip_file_path}: {e}")
            else:
                print(f"unexpected file: {file}")
                sleep(10)
    return {"keep_zip_count": keep_zip_count, "keep_mol_count": keep_mol_count, "remove_zip_count": remove_zip_count}

def move_to_data(root_folder, year):
    os.makedirs(f"data/{year}", exist_ok=True)
    source_folder = root_folder
    root_basename = os.path.basename(root_folder)
    possible_inner_folder = os.path.join(root_folder, root_basename)
    if os.path.isdir(possible_inner_folder):
        source_folder = possible_inner_folder
    print(f"Moving files from {source_folder} to data/{year}/{root_basename}")
    # move all files in source_folder to data/year, keeping the same structure
    for subdir, dirs, files in os.walk(source_folder):
        if len(files) == 0:
            continue # skip empty directories
        target_subdir = subdir
        if root_folder != source_folder and subdir.startswith(source_folder):
            target_subdir = root_basename + subdir[len(source_folder):]
        os.makedirs(os.path.join("data", year, target_subdir), exist_ok=True)
        for file in files:
            vprint(f"Moving {subdir}/{file}")
            file_path = os.path.join(subdir, file)
            new_path = os.path.join("data", year, target_subdir, file)
            try:
                os.rename(file_path, new_path)
            except FileExistsError:
                print(f"File {new_path} already exists, skipping")
    return os.path.join("data", year, root_basename)
                
def run_command(cmd, retry=0):
    return_code = os.system(cmd)
    if return_code != 0:
        if retry <= 0:
            raise Exception(f"Failed to run command {cmd}, return code {return_code}")
        else:
            print(f"Retrying {cmd} in 5 seconds (retries left {retry})")
            sleep(5)
            run_command(cmd, retry=retry-1)

def check_staged_files():
    result = subprocess.run(["git", "diff", "--cached", "--name-only"], capture_output=True, text=True)
    if result.stdout.strip():
        print("There are staged files ready to be committed.")
        return True
    else:
        vprint("No staged files found.")
        return False

def add_to_git(change_message, commit_message, root_folder = "data"):
    while check_staged_files():
        print("Please commit or reset the staged files before continuing")
        sleep(10)
    run_command(f"git add {root_folder}")
    with open("DATA-CHANGELOG.md", "a") as f:
        f.write(f"## {datetime.now().astimezone().isoformat()}\n{change_message}\n")
    run_command(f"git add DATA-CHANGELOG.md")
    run_command(f"git commit -m \"{shlex.quote(commit_message)}\"")
    #return False # not pushed
    run_command("git push", retry=0)
    return True
    

def is_processed(folder_name):
    try:
        with open("DATA-CHANGELOG.md") as f:
            return folder_name in f.read()
    except FileNotFoundError:
        return False

def get_parser():
    parser = argparse.ArgumentParser(description="Downloads and filters patent files for mol files from USPTO website, then adds them to a dataset")
    parser.add_argument("--quick", action='store_true', help="only processed at most one new weekly file, you can also create a file named 'quick' (touch quick) to enable this flag during runtime to exit after finishing processing the current weekly file")
    parser.add_argument("--keep", action='store_true', help="keep the original downloaded files")
    parser.add_argument("--stream", action='store_true', help="remove all pushed lfs files and objects locally. DO NOT USE WHEN RUNNING PARALLEL SCRIPTS")
    parser.add_argument("--verbose", action='store_true', help="print verbose logs")
    parser.add_argument("--from_year", default=2001, type=int, help="start from this year (default 2001 is the earliest available)")
    parser.add_argument("--to_year", default=datetime.now().year, type=int, help="end at this year (default current year)")
    return parser

def main(args):
    global is_verbose
    is_verbose = args.verbose
    years = [str(i) for i in range(args.from_year, args.to_year + 1)]
    for year in years:
        patent_link = scrape_uspto(year)
        for link in patent_link:
            packed_file = link.split("/")[-1]
            folder_name = packed_file.split(".")[0]
            if is_processed(folder_name):
                print(f"Skipping {folder_name}, already logged in DATA-CHANGELOG.md")
                continue
            folder_name = extract_link(link)
            stats = remove_unwanted_files(folder_name)
            print(stats)
            data_location = move_to_data(folder_name, year)
            pushed = add_to_git(f'Added data from {folder_name}\n{stats}', f'Added data from {folder_name}',data_location)
            if pushed and args.stream:
                os.system(f"rm -r {data_location}")
                os.system(f"rm -r .git/lfs/objects")
            if not args.keep:
                os.system(f"rm -r {folder_name}")
                os.system(f"rm {packed_file}")
            if os.path.exists("quick"): # create this file to stop the script most gracefully
                args.quick = True
            if args.quick:
                break
        if args.quick:
            break

if __name__ == "__main__":
    args = get_parser().parse_args()
    main(args)