
import asyncio
import aiohttp
import requests
import pandas as pd

from typing import List
from hamilton.function_modifiers import tag
 

class AsyncWebscraper:
    """Get data asynchronously to speed up fetching data from endpoints."""
    
    async def fetch(self, session: aiohttp.ClientSession, url: str) -> dict:
        """Fetch data from a given URL and return it as a DataFrame."""
        async with session.get(url) as response:
            data = await response.json()
            # assert "@id" in list(data.keys()), f"`@id` is not present in keys for {url=}"
            return data

    async def get_data(self, endpoints: List[str]) -> List[dict]:
        """Fetch data from all provided endpoints asynchronously."""
        async with aiohttp.ClientSession() as session:
            tasks = [self.fetch(session, url) for url in endpoints]
            results = await asyncio.gather(*tasks)
            return results
        

def _get_data(endpoint: str, base_url = "https://api.weather.gov") -> dict:
    # https://api.weather.gov/openapi.json
    url = f"{base_url}/{endpoint}"
    r = requests.get(url)
    r.raise_for_status()
    return r.json()


def product_codes() -> list:
    """Non-async endpoint response."""
    _product_types = _get_data(f"products/types")["@graph"]
    _product_codes = [i["productCode"] for i in _product_types]
    return _product_codes


async def product_endpoints(product_codes: list) -> list:
    endpoints  = [f"https://api.weather.gov/products/types/{cd}" for cd in product_codes]
    webscraper = AsyncWebscraper()
    data = await webscraper.get_data(endpoints=endpoints)
    return data 
    

def live_endpoints(product_endpoints: list) -> pd.DataFrame:
    return pd.DataFrame([p for p in product_endpoints if p.get("@graph")])


@tag(status="breaks")
def dead_endpoints(product_endpoints: list) -> pd.DataFrame:
    return pd.DataFrame([p for p in product_endpoints if not p.get("@graph")])


@tag(status="breaks")
def other_break() -> pd.DataFrame:
    return pd.DataFrame(dict(breaks=[1,2,3]))


if __name__ == "__main__":

    # python
    # codes = product_codes()[:2]
    # ao = asyncio.run(
    #     product_endpoints(codes + ["UVI"])
    # )

    # print(ao)

    # hamilton
    from hamilton import base
    from hamilton.async_driver import Builder
    
    import __main__ 


    dr = asyncio.run(
        Builder()
        .with_adapters(base.PandasDataFrameResult())
        .with_modules(__main__)
        .build()
        )
    
    o = asyncio.run(dr.execute(["live_endpoints"]))
    print(o)
    
    breaks_nodes = dr.list_available_variables(tag_filter={"status":"breaks"})
    print(breaks_nodes)
    for _break in breaks_nodes:
        b = asyncio.run(
            dr.execute([_break])
        )


