# Please be kind
# See https://github.com/developmentseed/awspds-mosaic
# to deploy your own
endpoint = "https://landsatlive.live"

# Define AOI here
bounds = [-5.833740234375, 46.15700496290803, -0.9118652343749999, 49.23912083246698]

# Date Filters
start = "2019-01-01T00:00:00Z"
end = "2019-12-31T23:59:59Z"

# SAT-API QUERY
# see http://sat-utils.github.io/sat-api/
query = {
    "bbox": bounds,
    "time": f"{start}/{end}",
    "query": {
        "eo:sun_elevation": {"gt": 0},
        "landsat:tier": {"eq": "T1"},
        "collection": {"eq": "landsat-8-l1"},
        "eo:cloud_cover": {"gte": 0, "lt": 3},  # Cloud Filters
    },
    "sort": [{"field": "eo:cloud_cover", "direction": "asc"}],
}

tilescale = 2  # Each tile will be 512x512px
tilesize = 256 * tilescale

# We post the query to the mosaic endpoint with some optional parameters
results = requests.post(
    f"{endpoint}/mosaic/create",
    json=query,
    params={
        # Landsat covers zoom 7 to 12 but
        # because we don't want to use the mosaic for visualization
        # purpose we don't really care about lower zoom level.
        # We could use zoom 11 but don't want to make the mosaicJSON file too big.
        # Minzoom define the quadkey zoom and thus the number of quadkey list
        # See https://github.com/developmentseed/mosaicjson-spec/tree/master/0.0.2
        "minzoom": 9,
        # We filter the season to have greenest data
        "seasons": "spring,summer",
        # Here we can also pass some tile option to be added to the tile url.
        "tile_format": "tif",  # We use GeoTIFF output from the tiler
        "tile_scale": tilescale,
    },
).json()

# Get Mercator tiles covering the AOI
# For Landsat the maxzoom is 12 (~38m resolution, in Web Mercator projection)
# because we use 512x512 pixel tiles we can 
# fetch tiles at zoom 11 instead of 12.
zoom = results["maxzoom"] - (tilescale - 1)

extrema = tile_extrema(bounds, zoom)
tiles = []
for x in range(extrema["x"]["min"], extrema["x"]["max"]):
    for y in range(extrema["y"]["min"], extrema["y"]["max"]):
        tiles.append(mercantile.Tile(z=zoom, x=x, y=y))

random.shuffle(tiles)

# Create tile URL
# See https://landsatlive.live/tiles/docs for the list of options you can pass to the tile url
query_params = dict(
    bands="4,3,2", # True Color RGB
    color_ops="gamma RGB 3.5, saturation 1.7, sigmoidal RGB 15 0.35", # Looks nice
    pixel_selection="median",  # See https://github.com/cogeotiff/rio-tiler-mosaic/blob/master/rio_tiler_mosaic/methods/defaults.py#L86
)
tiles_url = results["tiles"][0] + urllib.parse.urlencode(query_params)

def _worker(tile, retry=0):
    """
    Tile Worker.
    
    Call the tile endpoint for each mercator tile.
    
    """
    url = tiles_url.format(z=tile.z, x=tile.x, y=tile.y)
    img = requests.get(url)
    if not img.status_code == 200:
        if retry == 3:
            raise Exception("Empty")
        return _worker(tile, retry=retry+1)

    row = (tile.y - extrema["y"]["min"]) * tilesize
    col = (tile.x - extrema["x"]["min"]) * tilesize
    window = Window(col_off=col, row_off=row, width=tilesize, height=tilesize)

    return window, img

# Define Output COG parameters
width = (extrema["x"]["max"] - extrema["x"]["min"]) * tilesize
height = (extrema["y"]["max"] - extrema["y"]["min"]) * tilesize
w, n = mercantile.xy(
    *mercantile.ul(extrema["x"]["min"], extrema["y"]["min"], zoom)
)
res = _meters_per_pixel(zoom, 0, tilesize=tilesize)

params = dict(
    driver="GTiff",
    dtype="uint8",
    count=3,
    width=width,
    height=height,
    crs="epsg:3857",
    transform=Affine(res, 0, w, 0, -res, n),
    nodata=0,
    tiled=True,
    blockxsize=tilesize,
    blockysize=tilesize,
)
output_profile = cog_profiles.get("deflate")

# Distribute the processes using multithreading
# and then re-assemble the tiles in one COG
with rasterio.Env():
    with MemoryFile() as memfile:
        with memfile.open(**params) as mem:
            with futures.ThreadPoolExecutor(max_workers=50) as executor:
                future_work = [
                    executor.submit(_worker, tile) for tile in tiles
                ]
                
                for f in tqdm(futures.as_completed(future_work), total=len(future_work)):               
                    pass

            for f in _filter_futures(future_work):
                window, img = f
                with rasterio.open(BytesIO(img.content)) as src_dst:
                    mem.write(src_dst.read(indexes=(1,2,3)), window=window)

            cog_translate(
                mem,
                f"Bretagne_medianPixel_2019.tif",
                output_profile,
                config=dict(GDAL_NUM_THREADS="ALL_CPUS", GDAL_TIFF_OVR_BLOCKSIZE="128")
            )