app.py

import geopandas as gpd
import folium
import numpy as np
from folium.plugins import HeatMap, MeasureControl
import matplotlib.pyplot as plt
import io

from io import BytesIO
import base64
import json
import pandas as pd
from folium.plugins import HeatMapWithTime
from scipy.interpolate import griddata,bisplrep, bisplev
from pykrige.ok import OrdinaryKriging
from mpl_toolkits.axes_grid1 import make_axes_locatable
from matplotlib import cm
from matplotlib.colors import Normalize
from scipy import stats

import gradio as gr
import os
from dotenv import load_dotenv

load_dotenv()
groq_api_key=os.getenv('GROQ_API_KEY')

from groq import Groq
client = Groq(
    api_key=groq_api_key,
)

def interpolation_geojson(json_file, chem_symbol, lat_min, lat_max, long_min, long_max, method):
    try:
        # Load geochemical data from JSON file
        with open(json_file, 'r') as f:
            data = json.load(f)

        features = data['features']

        # Extract relevant properties into lists
        coordinates = []
        values = []

        for feature in features:
            properties = feature['properties']
            geometry = feature['geometry']
            latitude = geometry['coordinates'][1]
            longitude = geometry['coordinates'][0]
            if lat_min <= latitude <= lat_max and long_min <= longitude <= long_max:
                value = properties.get(chem_symbol, None)
                if value is not None and not np.isnan(value):  # Check for valid values
                    coordinates.append([latitude, longitude])
                    values.append(value)

        if not coordinates:
            return {"message": "No data found within specified coordinates."}

        # Normalize the values for Kriging interpolation
        values = np.array(values)
        normalized_values = (values - np.mean(values)) / np.std(values)

        # Add jitter to coordinates to avoid singular matrix error
        coordinates = np.array(coordinates)
        coordinates += np.random.normal(scale=1e-6, size=coordinates.shape)

        # Prepare grid for interpolation
        grid_lat = np.linspace(lat_min, lat_max, 100)
        grid_long = np.linspace(long_min, long_max, 100)
        grid_lat, grid_long = np.meshgrid(grid_lat, grid_long)

        # Perform interpolation
        points = np.array(coordinates)
        interpolation_type = "nan"
        if method == 1:
            # IDW Interpolation
            interpolation_type = "IDW"
            grid_z = griddata(points, values, (grid_lat, grid_long), method='cubic')
        elif method == 2:
            # Spline Interpolation
            interpolation_type = "Spline"
            tck = bisplrep(points[:, 0], points[:, 1], values, s=0)
            # s is the smoothing value and is chosen by trial and error
            grid_z = bisplev(grid_lat[:, 0], grid_long[0, :], tck)
        elif method == 3:
            # Kriging interpolation
            interpolation_type = "Kriging"
            try:
                variogram_model = 'spherical'  # Change this to other models if needed ('exponential', 'gaussian')
                OK = OrdinaryKriging(points[:, 0], points[:, 1], normalized_values, variogram_model=variogram_model, nlags=6)
                grid_z, _ = OK.execute('grid', grid_lat[0, :], grid_long[:, 0])
                # Denormalize the grid_z values
                grid_z = grid_z * np.std(values) + np.mean(values)
            except Exception as e:
                return {"message": f"Kriging interpolation error: {str(e)}"}
        elif method == 4:
            # Nearest Neighbor Interpolation
            interpolation_type = "Nearest Neighbor"
            grid_z = griddata(points, values, (grid_lat, grid_long), method='nearest')

        # Initialize the map centered around the mean of latitude and longitude limits
        map_center = [(lat_min + lat_max) / 2, (long_min + long_max) / 2]
        my_map = folium.Map(location=map_center, zoom_start=10, control_scale=True)

        # Add heatmap layer to the map
        heat_data = []
        for i in range(grid_lat.shape[0]):
            for j in range(grid_long.shape[1]):
                if not np.isnan(grid_z[i, j]):
                    heat_data.append([grid_lat[i, j], grid_long[i, j], grid_z[i, j]])

        HeatMap(heat_data, radius=15, blur=25, max_zoom=18, gradient={0.4: 'blue', 0.65: 'lime', 1: 'red'}).add_to(my_map)

        # # Add invisible tooltips (Popups) on hover for heatmap points
        # for lat, lon, value in heat_data:
        #     folium.Marker(
        #         location=[lat, lon],
        #         icon=folium.DivIcon(html=f"""<div style="display:none;">{value} ppm</div>"""),
        #         tooltip=f'{chem_symbol}: {value:.2f} ppm'
        #     ).add_to(my_map)

        # Add a color legend to the map
        colormap = folium.LinearColormap(
            colors=['green', 'orange', 'red'],
            vmin=np.min(values),
            vmax=np.max(values),
            caption=f'{chem_symbol} Concentration (ppm)'
        )
        colormap.add_to(my_map)
        my_map.add_child(MeasureControl())
        north_arrow_svg = """
        <div style="position: fixed; 
                    bottom: 30px; left: 10px; width: 40px; height: 40px; 
                    z-index: 1000; pointer-events: none;">
                    <div>North</div>
            <svg version="1.1" id="icons" xmlns="http://www.w3.org/2000/svg" x="0" y="0" viewBox="0 0 128 128" style="enable-background:new 0 0 128 128" xml:space="preserve">
                <style>.st0,.st1{display:none;fill:#191919}.st1,.st3{fill-rule:evenodd;clip-rule:evenodd}.st3,.st4{display:inline;fill:#191919}</style>
                <g id="row1">
                    <path id="nav:2_3_" d="M64 1 17.9 127 64 99.8l46.1 27.2L64 1zm0 20.4 32.6 89.2L64 91.3V21.4z" style="fill:#191919"/>
                </g>
            </svg>
        </div>
        """
        my_map.get_root().html.add_child(folium.Element(north_arrow_svg))
        # Save the map as an HTML string
        map_html = my_map.get_root().render()

        # Compute statistics
        data_mean = np.mean(values)
        data_median = np.median(values)
        data_mode = int(np.bincount(values.astype(int)).argmax()) if len(np.unique(values)) > 1 else 'No unique mode'
        data_stdev = np.std(values)
        data_variance = np.var(values)
        data_min = np.min(values)
        data_max = np.max(values)
        data_count = len(values)

        # Prepare message with statistics
        message = f"Heatmap of {interpolation_type} interpolated data created successfully for {chem_symbol}.\n"
        message += f"Statistics:\n"
        message += f"  - Mean: {data_mean:.2f} ppm\n"
        message += f"  - Median: {data_median:.2f} ppm\n"
        message += f"  - Mode: {data_mode} ppm\n"
        message += f"  - Std. Deviation: {data_stdev:.2f} ppm\n"
        message += f"  - Variance: {data_variance:.2f} ppm²\n"
        message += f"  - Min: {data_min:.2f} ppm\n"
        message += f"  - Max: {data_max:.2f} ppm\n"
        message += f"Number of points: {data_count}\n"
        return {"message": message, "html": map_html}

    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}


def plot_high_value_points(geojson_file, chem_symbol, lat_min, lat_max, long_min, long_max, threshold):
    """
    Plots points on a map for geochemical data that have values higher than a specified threshold.
    Also calculates and includes statistics (mean, mode, median, std deviation, variance) of the chemical values.

    Parameters:
    - geojson_file (str): The file path to the GeoJSON file containing geochemical data.
    - chem_symbol (str): The chemical symbol to visualize.
    - lat_min (float): The minimum latitude value.
    - lat_max (float): The maximum latitude value.
    - long_min (float): The minimum longitude value.
    - long_max (float): The maximum longitude value.
    - threshold (float): The threshold value for chemical concentration in ppm.

    Returns:
    - dict: A dictionary containing the message and HTML content of the generated map.
            {
                "message": str,
                "html": str (optional)
            }
    """
    # Define lat/long limits
    lat_limits = (lat_min, lat_max)
    long_limits = (long_min, long_max)

    try:
        # Load GeoJSON data
        gdf = gpd.read_file(geojson_file)
        
        # Check if the chemical symbol exists in the data
        if chem_symbol not in gdf.columns:
            return {"message": f"Error: Chemical symbol '{chem_symbol}' not found in the data."}
        
        # Filter data for the specified lat/long limits
        gdf = gdf[(gdf.geometry.y >= lat_limits[0]) & (gdf.geometry.y <= lat_limits[1]) & 
                  (gdf.geometry.x >= long_limits[0]) & (gdf.geometry.x <= long_limits[1])]
        
        if gdf.empty:
            return {"message": "Error: No data available within the specified lat/long limits."}
        
        # Calculate statistics of the chemical values
        chem_values = gdf[chem_symbol].values
        mean_value = np.mean(chem_values)
        mode_value = stats.mode(chem_values)
        median_value = np.median(chem_values)
        std_deviation = np.std(chem_values)
        variance = np.var(chem_values)
        data_count = len(chem_values)
        # Filter points with values higher than the threshold
        high_value_points = gdf[gdf[chem_symbol] > threshold]
        
        # Base map centered on the midpoint of the given lat/long limits
        lat_center = (lat_limits[0] + lat_limits[1]) / 2
        long_center = (long_limits[0] + long_limits[1]) / 2
        m = folium.Map(location=[lat_center, long_center], zoom_start=10, control_scale=True)
        
        # Add markers for high value points with tooltips
        for idx, row in high_value_points.iterrows():
            tooltip_text = (f'{chem_symbol}: {row[chem_symbol]:.2f} ppm<br>'
                            f'Coordinates: ({row.geometry.y:.6f}, {row.geometry.x:.6f})')
            folium.Marker(
                location=[row.geometry.y, row.geometry.x],
                tooltip=tooltip_text
            ).add_to(m)
        
        # Add layer control to toggle markers
        folium.LayerControl().add_to(m)
        # Add Measure Control with custom CSS to position it lower
        measure_control = MeasureControl()
        m.add_child(measure_control)
        
        measure_control_css = """
        <style>
        .leaflet-control-measure {
            top: 60px !important;  /* Adjust this value to move the control lower */
        }
        </style>
        """
        m.get_root().html.add_child(folium.Element(measure_control_css))


        north_arrow_svg = """
        <div style="position: fixed; 
                    top: 40px; right: 10px; width: 40px; height: 40px; 
                    z-index: 1000; pointer-events: none;">
                    <div style="margin-top:22px;">North</div>
            <svg version="1.1" id="icons" xmlns="http://www.w3.org/2000/svg" x="0" y="0" viewBox="0 0 128 128" style="enable-background:new 0 0 128 128" xml:space="preserve">
                <style>.st0,.st1{display:none;fill:#191919}.st1,.st3{fill-rule:evenodd;clip-rule:evenodd}.st3,.st4{display:inline;fill:#191919}</style>
                <g id="row1">
                    <path id="nav:2_3_" d="M64 1 17.9 127 64 99.8l46.1 27.2L64 1zm0 20.4 32.6 89.2L64 91.3V21.4z" style="fill:#191919"/>
                </g>
            </svg>
        </div>
        """
        m.get_root().html.add_child(folium.Element(north_arrow_svg))
        # Generate the HTML content
        html_content = m.get_root().render()
        
        # Construct the message with statistics
        message = f"Plotted points with '{chem_symbol}' values higher than {threshold:.2f} ppm\n"
        message += f"Mean: {mean_value:.2f} ppm\n"
        message += f"Mode: {mode_value} ppm\n"
        message += f"Median: {median_value:.2f} ppm\n"
        message += f"Standard Deviation: {std_deviation:.2f} ppm\n"
        message += f"Variance: {variance:.2f} ppm\n"
        message += f"Number of points: {data_count}\n"
        return {
            "message": message,
            "html": html_content
        }
    
    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}
        


def create_heatmap(geojson_file, chem_symbol, lat_min, lat_max, long_min, long_max):
    """
    Generates a heatmap from geochemical data within specified latitudinal and longitudinal limits.

    Parameters:
    - geojson_file (str): The file path to the GeoJSON file containing geochemical data.
    - chem_symbol (str): The chemical symbol to visualize.
    - lat_min (float): The minimum latitude value.
    - lat_max (float): The maximum latitude value.
    - long_min (float): The minimum longitude value.
    - long_max (float): The maximum longitude value.

    Returns:
    - dict: A dictionary containing the message and HTML content of the generated heatmap.
            {
                "message": str,
                "html": str (optional)
            }
    """
    # Define lat/long limits
    lat_limits = (lat_min, lat_max)
    long_limits = (long_min, long_max)

    try:
        # Load GeoJSON data
        gdf = gpd.read_file(geojson_file)
        
        # Check if the chemical symbol exists in the data
        if chem_symbol not in gdf.columns:
            return {"message": f"Error: Chemical symbol '{chem_symbol}' not found in the data."}
        
        # Filter data for the specified lat/long limits
        gdf = gdf[(gdf.geometry.y >= lat_limits[0]) & (gdf.geometry.y <= lat_limits[1]) & 
                  (gdf.geometry.x >= long_limits[0]) & (gdf.geometry.x <= long_limits[1])]
        
        if gdf.empty:
            return {"message": "Error: No data available within the specified lat/long limits."}
        
        # Prepare data for heatmap
        heat_data = [[point.y, point.x, value] for point, value in zip(gdf.geometry, gdf[chem_symbol])]
        
        # Base map centered on the midpoint of the given lat/long limits
        lat_center = (lat_limits[0] + lat_limits[1]) / 2
        long_center = (long_limits[0] + long_limits[1]) / 2
        m = folium.Map(location=[lat_center, long_center], zoom_start=10, control_scale=True)
        
        # Add heatmap layer
        heatmap_layer = HeatMap(heat_data, min_opacity=0.2, radius=15, blur=15)
        heatmap_layer.add_to(m)
        
        # Add invisible markers with tooltips for interactivity
        for point, value in zip(gdf.geometry, gdf[chem_symbol]):
            folium.Marker(
                location=[point.y, point.x],
                icon=folium.DivIcon(html=f"""<div style="display:none;">{value} ppm</div>"""),
                tooltip=f'{chem_symbol}: {value} ppm'
            ).add_to(m)
        
        # Add layer control to toggle heatmap
        folium.LayerControl().add_to(m)
        # max_value = gdf[chem_symbol].max()
        # medium_threshold = max_value / 2
        # low_threshold = 0
        # Define value thresholds for the legend
        low_threshold = gdf[chem_symbol].min()
        #medium_threshold = high_threshold/2  # Adjust these values based on your data
        high_threshold = gdf[chem_symbol].max()

        # Add a color legend to the map
        colormap = folium.LinearColormap(
            colors=['green', 'orange', 'red'],
            vmin=low_threshold,
            vmax=high_threshold,
            caption=f'{chem_symbol} Concentration (ppm)'
        )
        colormap.add_to(m)


        m.add_child(MeasureControl())
        north_arrow_svg = """
        <div style="position: fixed; 
                    bottom: 30px; left: 10px; width: 40px; height: 40px; 
                    z-index: 1000; pointer-events: none;">
                    <div>North</div>
            <svg version="1.1" id="icons" xmlns="http://www.w3.org/2000/svg" x="0" y="0" viewBox="0 0 128 128" style="enable-background:new 0 0 128 128" xml:space="preserve">
                <style>.st0,.st1{display:none;fill:#191919}.st1,.st3{fill-rule:evenodd;clip-rule:evenodd}.st3,.st4{display:inline;fill:#191919}</style>
                <g id="row1">
                    <path id="nav:2_3_" d="M64 1 17.9 127 64 99.8l46.1 27.2L64 1zm0 20.4 32.6 89.2L64 91.3V21.4z" style="fill:#191919"/>
                </g>
            </svg>
        </div>
        """
        m.get_root().html.add_child(folium.Element(north_arrow_svg))
        
        # Generate the HTML content
        html_content = m.get_root().render()
        chem_values = gdf[chem_symbol].values
        mean_value = np.mean(chem_values)
        mode_value = stats.mode(chem_values)  # Mode can have multiple values, taking the first one
        median_value = np.median(chem_values)
        std_deviation = np.std(chem_values)
        variance = np.var(chem_values)
        data_count = len(chem_values)

        return {
            "message": f"Heatmap for '{chem_symbol}'."
            f"Here are the Statistics:\n"
            f"Mean: {mean_value:.2f} ppm\n"
            f"Median: {median_value:.2f} ppm\n"
            f"Mode: {mode_value} ppm\n"
            f"Standard Deviation: {std_deviation:.2f} ppm\n"
            f"Variance: {variance:.2f} ppm^2\n"
            f"Minimum: {low_threshold:.2f} ppm\n"
            f"Maximum: {high_threshold:.2f} ppm\n"
            f"Number of points: {data_count}",
            "html": html_content
        }
    
    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}



def create_heatmap_old(geojson_file, chem_symbol, lat_min, lat_max, long_min, long_max):
    """
    Generates a heatmap from geochemical data within specified latitudinal and longitudinal limits.

    Parameters:
    - geojson_file (str): The file path to the GeoJSON file containing geochemical data.
    - chem_symbol (str): The chemical symbol to visualize.
    - lat_min (float): The minimum latitude value.
    - lat_max (float): The maximum latitude value.
    - long_min (float): The minimum longitude value.
    - long_max (float): The maximum longitude value.

    Returns:
    - dict: A dictionary containing the message and HTML content of the generated heatmap.
            {
                "message": str,
                "html": str (optional)
            }
    """
    # lat/long limits
    lat_limits = (lat_min, lat_max)
    long_limits = (long_min, long_max)

    try:
        # GeoJSON data
        gdf = gpd.read_file(geojson_file)
        
        if chem_symbol not in gdf.columns:
            return {"message": f"Error: Chemical symbol '{chem_symbol}' not found in the data."}
        
        # Filter data for the specified lat/long limits
        gdf = gdf[(gdf.geometry.y >= lat_limits[0]) & (gdf.geometry.y <= lat_limits[1]) & 
                  (gdf.geometry.x >= long_limits[0]) & (gdf.geometry.x <= long_limits[1])]
        
        if gdf.empty:
            return {"message": "Error: No data available within the specified lat/long limits."}
        
        # Prepare data for heatmap
        heat_data = [[point.y, point.x, value] for point, value in zip(gdf.geometry, gdf[chem_symbol])]
        
        # Base map centered on the midpoint
        lat_center = (lat_limits[0] + lat_limits[1]) / 2
        long_center = (long_limits[0] + long_limits[1]) / 2
        m = folium.Map(location=[lat_center, long_center], zoom_start=10)
        
        # Add heatmap layer
        heatmap_layer = HeatMap(heat_data, min_opacity=0.2, radius=15, blur=15)
        heatmap_layer.add_to(m)
        
        # Add invisible markers with tooltips
        for point, value in zip(gdf.geometry, gdf[chem_symbol]):
            folium.Marker(
                location=[point.y, point.x],
                icon=folium.DivIcon(html=f"""<div style="display:none;">{value}</div>"""),
                tooltip=f'{chem_symbol}: {value}'
            ).add_to(m)
        
        # layer control to toggle heatmap
        folium.LayerControl().add_to(m)
        
        html_content = m.get_root().render()
        
        return {
            "message": f"Here is your Heatmap for '{chem_symbol}'.",
            "html": html_content
        }
    
    except Exception as e:
        return {"message": f"An error occurred while I was creating the heatmap: {str(e)}"}


def interpolation_contour(json_file, chem_symbol, lat_min, lat_max, long_min, long_max, method): #USING CONTOUR
    try:
        # Load geochemical data from JSON file
        with open(json_file, 'r') as f:
            data = json.load(f)

        features = data['features']

        # Extract relevant properties into lists
        coordinates = []
        values = []

        for feature in features:
            properties = feature['properties']
            geometry = feature['geometry']
            latitude = geometry['coordinates'][1]
            longitude = geometry['coordinates'][0]
            if lat_min <= latitude <= lat_max and long_min <= longitude <= long_max:
                value = properties.get(chem_symbol, None)
                if value is not None and not np.isnan(value):  # Check for valid values
                    coordinates.append([latitude, longitude])
                    values.append(value)

        if not coordinates:
            return {"message": "No data found within specified coordinates."}

        # Normalize the values for Kriging interpolation
        values = np.array(values)
        normalized_values = (values - np.mean(values)) / np.std(values)

        # Add jitter to coordinates to avoid singular matrix error
        coordinates = np.array(coordinates)
        coordinates += np.random.normal(scale=1e-6, size=coordinates.shape)

        # Prepare grid for interpolation
        grid_lat = np.linspace(lat_min, lat_max, 100)
        grid_long = np.linspace(long_min, long_max, 100)
        grid_lat, grid_long = np.meshgrid(grid_lat, grid_long)

        # Perform interpolation
        points = np.array(coordinates)
        interpolation_type = "nan"
        if method == 1:
            # IDW Interpolation
            interpolation_type = "IDW"
            grid_z = griddata(points, values, (grid_lat, grid_long), method='cubic')
        elif method == 2:
            # Spline Interpolation
            interpolation_type = "Spline"
            tck = bisplrep(points[:, 0], points[:, 1], values, s=0)
            # s is the smoothing value and is chosen by trial and error
            grid_z = bisplev(grid_lat[:, 0], grid_long[0, :], tck)
        elif method == 3:
            # Kriging interpolation
            interpolation_type = "Kriging"
            try:
                variogram_model = 'spherical'  # Change this to other models if needed ('exponential', 'gaussian')
                OK = OrdinaryKriging(points[:, 0], points[:, 1], normalized_values, variogram_model=variogram_model, nlags=6)
                grid_z, _ = OK.execute('grid', grid_lat[0, :], grid_long[:, 0])
                # Denormalize the grid_z values
                grid_z = grid_z * np.std(values) + np.mean(values)
            except Exception as e:
                return {"message": f"Kriging interpolation error: {str(e)}"}
        elif method == 4:
            # Nearest Neighbor Interpolation
            interpolation_type = "Nearest Neighbor"
            grid_z = griddata(points, values, (grid_lat, grid_long), method='nearest')

        # Generate the contour plot
        fig, ax = plt.subplots()
        contour = ax.contourf(grid_long, grid_lat, grid_z, cmap=cm.jet, alpha=0.6)  # Adjust the colormap as needed
        cbar = plt.colorbar(contour, ax=ax, label=f'{chem_symbol} Concentration (ppm)')
        ax.axis('off')
        # Save the contour plot to a PNG image in memory
        buf = io.BytesIO()
        plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0)
        plt.close(fig)
        buf.seek(0)
        image_base64 = base64.b64encode(buf.read()).decode('utf-8')

        # Initialize the map centered around the mean of latitude and longitude limits
        map_center = [(lat_min + lat_max) / 2, (long_min + long_max) / 2]
        my_map = folium.Map(location=map_center, zoom_start=10, control_scale=True)

        # Overlay the contour plot image on the map
        folium.raster_layers.ImageOverlay(
            image=f'data:image/png;base64,{image_base64}',
            bounds=[[lat_min, long_min], [lat_max, long_max]],
            opacity=0.6
        ).add_to(my_map)

        # Add layer control to toggle contour image
        folium.LayerControl().add_to(my_map)

        # # Add a color legend to the map
        # colormap = folium.LinearColormap(
        #     colors=['green', 'orange', 'red'],
        #     vmin=np.min(values),
        #     vmax=np.max(values),
        #     caption=f'{chem_symbol} Concentration (ppm)'
        # )
        # colormap.add_to(my_map)
        measure_control = MeasureControl()
        my_map.add_child(measure_control)
        
        measure_control_css = """
        <style>
        .leaflet-control-measure {
            top: 60px !important;  /* Adjust this value to move the control lower */
        }
        </style>
        """
        my_map.get_root().html.add_child(folium.Element(measure_control_css))


        north_arrow_svg = """
        <div style="position: fixed; 
                    top: 40px; right: 10px; width: 40px; height: 40px; 
                    z-index: 1000; pointer-events: none;">
                    <div style="margin-top:22px;">North</div>
            <svg version="1.1" id="icons" xmlns="http://www.w3.org/2000/svg" x="0" y="0" viewBox="0 0 128 128" style="enable-background:new 0 0 128 128" xml:space="preserve">
                <style>.st0,.st1{display:none;fill:#191919}.st1,.st3{fill-rule:evenodd;clip-rule:evenodd}.st3,.st4{display:inline;fill:#191919}</style>
                <g id="row1">
                    <path id="nav:2_3_" d="M64 1 17.9 127 64 99.8l46.1 27.2L64 1zm0 20.4 32.6 89.2L64 91.3V21.4z" style="fill:#191919"/>
                </g>
            </svg>
        </div>
        """
        my_map.get_root().html.add_child(folium.Element(north_arrow_svg))

        # Save the map as an HTML string
        map_html = my_map.get_root().render()

        # Compute statistics
        data_mean = np.mean(values)
        data_median = np.median(values)
        data_mode = int(np.bincount(values.astype(int)).argmax()) if len(np.unique(values)) > 1 else 'No unique mode'
        data_stdev = np.std(values)
        data_variance = np.var(values)
        data_min = np.min(values)
        data_max = np.max(values)
        data_count = len(values)

        # Prepare message with statistics
        message = f"Contour map of {interpolation_type} interpolated data created successfully for {chem_symbol}.\n"
        message += f"Statistics:\n"
        message += f"  - Mean: {data_mean:.2f} ppm\n"
        message += f"  - Median: {data_median:.2f} ppm\n"
        message += f"  - Mode: {data_mode} ppm\n"
        message += f"  - Std. Deviation: {data_stdev:.2f} ppm\n"
        message += f"  - Variance: {data_variance:.2f} ppm²\n"
        message += f"  - Min: {data_min:.2f} ppm\n"
        message += f"  - Max: {data_max:.2f} ppm\n"
        message += f"Number of points: {data_count}"

        return {"message": message, "html": map_html}

    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}



def create_geochem_avg_histogram(geojson_file, chem_symbols, lat_min, lat_max, long_min, long_max):
    
    try:
        geo_data = gpd.read_file(geojson_file)
        
        filtered_data = geo_data.cx[long_min:long_max, lat_min:lat_max]
        # a dictionary to store average values for each chemical
        avg_values = {}
        
        # Calculate average concentration for each chemical symbol
        for chem_symbol in chem_symbols:
            if chem_symbol in filtered_data.columns:
                avg_value = filtered_data[chem_symbol].mean()
                avg_values[chem_symbol] = avg_value
            # If there's no data for the chemical symbol, skip it
            else:
                print(f"no data for {chem_symbol}")
            
        # Find the chemical with the highest average concentration
        max_avg_chem = max(avg_values, key=avg_values.get) if avg_values else None
        max_avg_value = avg_values[max_avg_chem] if max_avg_chem else None
        
        # Create the histogram
        if avg_values:
            plt.figure(figsize=(10, 6))
            plt.bar(avg_values.keys(), avg_values.values(), color='skyblue')
            plt.xlabel('Chemical Symbols')
            plt.ylabel('Average Concentration')
            plt.title('Average Concentration of Chemicals')
            
            # Save the plot to a BytesIO object
            buf = BytesIO()
            plt.savefig(buf, format='png')
            buf.seek(0)
            
            # Convert the plot to a base64 string
            img_base64 = base64.b64encode(buf.read()).decode('utf-8')
            plt.close()
            
            # Create the HTML content
            html_content = f'<img src="data:image/png;base64,{img_base64}" style="width: 500px; height: 400px;" />'

        else:
            html_content = '<p>No data available for the specified chemicals and area.</p>'
        
        # Create the JSON response
        response = {
            "message": f"Take a look at the histogram with maximum being {max_avg_chem} with value of {max_avg_value}.",
            "html": html_content
        }
        
        return response
    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}


def interpolation_geojsonold(json_file, chem_symbol, lat_min, lat_max, long_min, long_max, method):
    try:
        # from JSON file into a DataFrame
        with open(json_file, 'r') as f:
            data = json.load(f)

        features = data['features']

        # Extract relevant properties into lists
        coordinates = []
        values = []

        for feature in features:
            properties = feature['properties']
            geometry = feature['geometry']
            latitude = geometry['coordinates'][1]
            longitude = geometry['coordinates'][0]
            if lat_min <= latitude <= lat_max and long_min <= longitude <= long_max:
                value = properties.get(chem_symbol, None)
                if value is not None and not np.isnan(value):  # Check for valid values
                    coordinates.append([latitude, longitude])
                    values.append(value)

        if not coordinates:
            return {"message":"No data found within specified coordinates."}

        # Create a DataFrame from extracted data
        df = pd.DataFrame({'Latitude': [coord[0] for coord in coordinates],
                           'Longitude': [coord[1] for coord in coordinates],
                           'Value': values})

        # grid for interpolation
        grid_lat = np.linspace(lat_min, lat_max, 100)
        grid_long = np.linspace(long_min, long_max, 100)
        grid_lat, grid_long = np.meshgrid(grid_lat, grid_long)

        points = np.array(coordinates)
        values = np.array(values)
        interpolation_type="nan"
        if method==1:
            #IDW Interpolation
            interpolation_type = "IDW"
            grid_z = griddata(points, values, (grid_lat, grid_long), method='cubic')
        elif method==2:
            #Spline Interpolation:
            interpolation_type = "Spline"
            tck = bisplrep(points[:, 0], points[:, 1], values, s=0)
            #s is the smoothing value and is chosen by trial and error
            grid_z = bisplev(grid_lat[:, 0], grid_long[0, :], tck)
        elif method==3:
            #Kriging interpolation
            interpolation_type = "Kriging"
            OK = OrdinaryKriging(points[:, 0], points[:, 1], values, variogram_model='linear')
            grid_z, _ = OK.execute('grid', grid_lat[0, :], grid_long[:, 0])
            
        elif method==4:
            #Nearest Neighbor
            interpolation_type = "Nearest Neighbor"
            grid_z = griddata(points, values, (grid_lat, grid_long), method='nearest')

        # Initialize the map centered around the mean
        map_center = [(lat_min + lat_max) / 2, (long_min + long_max) / 2]
        my_map = folium.Map(location=map_center, zoom_start=10)

        # Add heatmap layer to the map
        heat_data = []
        for i in range(grid_lat.shape[0]):
            for j in range(grid_long.shape[1]):
                if not np.isnan(grid_z[i, j]):
                    heat_data.append([grid_lat[i, j], grid_long[i, j], grid_z[i, j]])

        HeatMap(heat_data, radius=15, blur=25, max_zoom=18).add_to(my_map)

        # Add legend to the map
        caption = f'{interpolation_type} Interpolated {chem_symbol} Heatmap'
        my_map.get_root().html.add_child(folium.Element(f'<div style="position: fixed; bottom: 50px; left: 50px; z-index:9999; background-color:white; padding: 10px; border: 2px solid grey; border-radius: 5px;">{caption}</div>'))

        # Save the map as an HTML string
        map_html = my_map.get_root().render()

        return {"message":f"Heatmap of {interpolation_type} interpolated data created successfully for {chem_symbol}.","html": map_html}

    except Exception as e:
        return {"message":f"An error occurred: {str(e)}"}

def plot_excavation_sites(geojson_file, lat_min, lat_max, long_min, long_max):
    """
    Plots excavation sites from GeoJSON data as markers on a map with hover tooltips and generates HTML content.

    Parameters:
    - geojson_file (str): The file path to the GeoJSON file containing excavation site data.
    - lat_min (float): The minimum latitude value.
    - lat_max (float): The maximum latitude value.
    - long_min (float): The minimum longitude value.
    - long_max (float): The maximum longitude value.

    Returns:
    - dict: A dictionary containing the message and HTML content of the generated map.
            {
                "message": str,
                "html": str (optional)
            }
    """
    lat_center = (lat_min + lat_max) / 2
    long_center = (long_min + long_max) / 2
    m = folium.Map(location=[lat_center, long_center], zoom_start=10, control_scale=True)

    try:
        
        with open(geojson_file, 'r') as f:
            data = json.load(f)

        # Iterate through each feature in the GeoJSON file. Use the coordinates of geometry and not feature(creates conflicts for magnetic)
        for feature in data['features']:
            properties = feature['properties']
            geometry = feature['geometry']

            if geometry['type'] == 'Polygon':
                coordinates = geometry['coordinates'][0]  # Extracting the coordinates of the Polygon

                # Check if any point of the polygon falls within the specified lat/long limits
                for coord in coordinates:
                    if (lat_min <= coord[1] <= lat_max and
                        long_min <= coord[0] <= long_max):
                        # Add marker for each excavation site
                        marker = folium.Marker(location=[coord[1], coord[0]],
                                               tooltip=f"Commodity: {properties.get('commodity', 'N/A')}",
                                               popup=f"<strong>Commodity:</strong> {properties.get('commodity', 'N/A')}<br>"
                                                     f"<strong>Exploration Agency:</strong> {properties.get('name_of_exploration_agency', 'N/A')}<br>"
                                                     f"<strong>Project Title:</strong> {properties.get('project_title', 'N/A')}<br>"
                                                     f"<strong>Exploration Stage:</strong> {properties.get('exploration_stage', 'N/A')}<br>"
                                                     f"<strong>from:</strong> {properties.get('period_of_propecting_from', 'N/A')}<strong> to:</strong>{properties.get('period_of_propecting_to', 'N/A')}<br>"
                                                     f"<strong>Prospector name:</strong> {properties.get('name_of_the_prospector','N/A')}<br>")
                        marker.add_to(m)

        # Generate the HTML content
        m.add_child(MeasureControl())
        north_arrow_svg = """
        <div style="position: fixed; 
                    bottom: 30px; left: 10px; width: 40px; height: 40px; 
                    z-index: 1000; pointer-events: none;">
                    <div>North</div>
            <svg version="1.1" id="icons" xmlns="http://www.w3.org/2000/svg" x="0" y="0" viewBox="0 0 128 128" style="enable-background:new 0 0 128 128" xml:space="preserve">
                <style>.st0,.st1{display:none;fill:#191919}.st1,.st3{fill-rule:evenodd;clip-rule:evenodd}.st3,.st4{display:inline;fill:#191919}</style>
                <g id="row1">
                    <path id="nav:2_3_" d="M64 1 17.9 127 64 99.8l46.1 27.2L64 1zm0 20.4 32.6 89.2L64 91.3V21.4z" style="fill:#191919"/>
                </g>
            </svg>
        </div>
        """
        m.get_root().html.add_child(folium.Element(north_arrow_svg))
        html_content = m.get_root().render()

        return {
            "message": "Excavation sites plotted successfully. You can click on the tags to know more about the excavation sites",
            "html": html_content
        }

    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}



def create_dem_mayavi( geojson_file, lat_min, lat_max, long_min, long_max):
    """
    Creates a DEM from geomorphological data in a GeoJSON file and returns an HTML representation.

    Parameters:
    - lat_min, lat_max: Latitude boundaries.
    - long_min, long_max: Longitude boundaries.
    - geojson_file: Path to the GeoJSON file.

    Returns:
    - dict: A dictionary with a message and HTML content of the DEM.
    """
    try:
        # Load GeoJSON data
        gdf = gpd.read_file(geojson_file)
        
        # Filter data within specified lat/long limits
        gdf = gdf.cx[long_min:long_max, lat_min:lat_max]
        
        if gdf.empty:
            return {"message": "Error: No data available within the specified lat/long limits."}
        
        # Extract coordinates and elevation values
        coordinates = []
        elevations = []
        
        for feature in gdf.itertuples():
            if feature.geometry.type == 'Polygon':
                coords = np.array(feature.geometry.exterior.coords)
                coordinates.extend(coords)
                elevations.extend([feature.shape_leng] * len(coords))
            # elif feature.geometry.type == 'MultiPolygon':
            #     for polygon in feature.geometry:
            #         coords = np.array(polygon.exterior.coords)
            #         coordinates.extend(coords)
            #         elevations.extend([feature.shape_leng] * len(coords))
        
        coordinates = np.array(coordinates)
        elevations = np.array(elevations)
        
        # Generate grid for DEM
        lats = np.linspace(lat_min, lat_max, 100)
        longs = np.linspace(long_min, long_max, 100)
        longs, lats = np.meshgrid(longs, lats)
        
        # Interpolate elevation values onto grid
        grid_z = griddata(coordinates[:, :2], elevations, (longs, lats), method='cubic')
        
        # Create DEM plot
        fig = mlab.figure(size=(800, 600), bgcolor=(1, 1, 1))
        dem_plot = mlab.surf(longs, lats, grid_z, warp_scale='auto', colormap='terrain')
        mlab.colorbar(title='Elevation', orientation='vertical')
        
        # Save the plot as HTML
        html_output = 'dem_plot.html'
        mlab.savefig(html_output)
        mlab.close()
        
        with open(html_output, 'r') as file:
            html_content = file.read()
        
        return {"message": "DEM generated successfully.", "html": html_content}
    
    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}


def create_dem(geojson_file, lat_min, lat_max, long_min, long_max):
    """
    Creates a 3D DEM from geomorphological data in a GeoJSON file and returns an HTML representation.

    Parameters:
    - lat_min, lat_max: Latitude boundaries.
    - long_min, long_max: Longitude boundaries.
    - geojson_file: Path to the GeoJSON file.

    Returns:
    - dict: A dictionary with a message and HTML content of the DEM.
    """
    try:
        # Load GeoJSON data
        gdf = gpd.read_file(geojson_file)
        
        # Filter data within specified lat/long limits
        gdf = gdf.cx[long_min:long_max, lat_min:lat_max]
        
        if gdf.empty:
            return {"message": "Error: No data available within the specified lat/long limits."}
        
        # Extract coordinates and elevation values
        coordinates = []
        elevations = []
        
        for feature in gdf.itertuples():
            if feature.geometry.geom_type == 'Polygon':
                coords = np.array(feature.geometry.exterior.coords)
                coordinates.extend(coords)
                elevations.extend([feature.shape_leng] * len(coords))
            # elif feature.geometry.geom_type == 'MultiPolygon':
            #     for polygon in feature.geometry:
            #         coords = np.array(polygon.exterior.coords)
            #         coordinates.extend(coords)
            #         elevations.extend([feature.shape_leng] * len(coords))
        
        coordinates = np.array(coordinates)
        elevations = np.array(elevations)
        
        # Generate grid for DEM
        lats = np.linspace(lat_min, lat_max, 100)
        longs = np.linspace(long_min, long_max, 100)
        longs, lats = np.meshgrid(longs, lats)
        
        # Interpolate elevation values onto grid
        grid_z = griddata(coordinates[:, :2], elevations, (longs, lats), method='cubic')
        
        # Create 3D DEM plot using matplotlib
        fig = plt.figure(figsize=(10, 8))
        ax = fig.add_subplot(111, projection='3d')
        ax.plot_surface(longs, lats, grid_z, cmap='terrain')
        ax.set_xlabel('Longitude')
        ax.set_ylabel('Latitude')
        ax.set_zlabel('Elevation')
        ax.set_title('Digital Elevation Model (DEM)')
        max_elevation = np.nanmax(grid_z)
        ax.set_zlim(0, max_elevation)
        # Save the plot to a bytes buffer
        buffer = BytesIO()
        plt.savefig(buffer, format='png')
        plt.close()
        
        # Encode the plot to a base64 string
        buffer.seek(0)
        img_str = base64.b64encode(buffer.read()).decode('utf-8')
        html_content = f'<img src="data:image/png;base64,{img_str}" />'
        
        return {"message": "3D DEM generated successfully.", "html": html_content}
    
    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}

from shapely.geometry import LineString

def create_contour_map(geojson_file, chem_symbol, lat_min, lat_max, long_min, long_max):
    """
    Generates a customized contour map overlay on a Folium map from geochemical data within specified latitudinal and longitudinal limits.

    Parameters:
    - geojson_file (str): The file path to the GeoJSON file containing geochemical data.
    - chem_symbol (str): The chemical symbol to visualize.
    - lat_min (float): The minimum latitude value.
    - lat_max (float): The maximum latitude value.
    - long_min (float): The minimum longitude value.
    - long_max (float): The maximum longitude value.

    Returns:
    - dict: A dictionary containing the message and HTML content of the generated contour map overlay.
            {
                "message": str,
                "html": str (optional)
            }
    """
    try:
        gdf = gpd.read_file(geojson_file)
        
        # Check if the chemical symbol exists in the data
        if chem_symbol not in gdf.columns:
            return {"message": f"Error: Chemical symbol '{chem_symbol}' not found in the data."}
        
        gdf = gdf[(gdf.geometry.y >= lat_min) & (gdf.geometry.y <= lat_max) & 
                  (gdf.geometry.x >= long_min) & (gdf.geometry.x <= long_max)]
        
        if gdf.empty:
            return {"message": "Error: No data available within the specified lat/long limits."}
        
        # data for contour plot
        latitudes = gdf.geometry.y.values
        longitudes = gdf.geometry.x.values
        values = gdf[chem_symbol].values
        
        # Create grid data
        grid_lat, grid_long = np.mgrid[lat_min:lat_max:100j, long_min:long_max:100j]
        grid_values = griddata((latitudes, longitudes), values, (grid_lat, grid_long), method='cubic')
        
        # Generate the contour plot with custom colormap
        fig, ax = plt.subplots()
        contour = ax.contourf(grid_long, grid_lat, grid_values, cmap=cm.jet, alpha=0.6)  
        cbar = plt.colorbar(contour, ax=ax, label=chem_symbol)
        
        ax.axis('off')  # Turning off axis lines
        
        buf = io.BytesIO()
        plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0)
        plt.close(fig)
        buf.seek(0)
        image_base64 = base64.b64encode(buf.read()).decode('utf-8')
        
        lat_center = (lat_min + lat_max) / 2
        long_center = (long_min + long_max) / 2
        m = folium.Map(location=[lat_center, long_center], zoom_start=12)
        
        # Overlaying the contour plot image
        folium.raster_layers.ImageOverlay(
            image=f'data:image/png;base64,{image_base64}',
            bounds=[[lat_min, long_min], [lat_max, long_max]],
            opacity=0.6
        ).add_to(m)
        
        # Add layer control to toggle contour image
        folium.LayerControl().add_to(m)
        m.add_child(MeasureControl())
        north_arrow_svg = """
        <div style="position: fixed; 
                    bottom: 30px; left: 10px; width: 40px; height: 40px; 
                    z-index: 1000; pointer-events: none;">
                    <div>North</div>
            <svg version="1.1" id="icons" xmlns="http://www.w3.org/2000/svg" x="0" y="0" viewBox="0 0 128 128" style="enable-background:new 0 0 128 128" xml:space="preserve">
                <style>.st0,.st1{display:none;fill:#191919}.st1,.st3{fill-rule:evenodd;clip-rule:evenodd}.st3,.st4{display:inline;fill:#191919}</style>
                <g id="row1">
                    <path id="nav:2_3_" d="M64 1 17.9 127 64 99.8l46.1 27.2L64 1zm0 20.4 32.6 89.2L64 91.3V21.4z" style="fill:#191919"/>
                </g>
            </svg>
        </div>
        """
        m.get_root().html.add_child(folium.Element(north_arrow_svg))
        html_content = m.get_root().render()
        
        return {
            "message": f"Your Contour map for '{chem_symbol}' is generated successfully. Please zoom in/out for a better view",
            "html": html_content
        }
    
    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}
                    

def plot_high_value_points(geojson_file, chem_symbol, lat_min, lat_max, long_min, long_max, threshold):
    """
    Plots points on a map for geochemical data that have values higher than a specified threshold.
    Also calculates and includes statistics (mean, mode, median, std deviation, variance) of the chemical values.

    Parameters:
    - geojson_file (str): The file path to the GeoJSON file containing geochemical data.
    - chem_symbol (str): The chemical symbol to visualize.
    - lat_min (float): The minimum latitude value.
    - lat_max (float): The maximum latitude value.
    - long_min (float): The minimum longitude value.
    - long_max (float): The maximum longitude value.
    - threshold (float): The threshold value for chemical concentration in ppm.

    Returns:
    - dict: A dictionary containing the message and HTML content of the generated map.
            {
                "message": str,
                "html": str (optional)
            }
    """
    # Define lat/long limits
    lat_limits = (lat_min, lat_max)
    long_limits = (long_min, long_max)

    try:
        # Load GeoJSON data
        gdf = gpd.read_file(geojson_file)
        
        # Check if the chemical symbol exists in the data
        if chem_symbol not in gdf.columns:
            return {"message": f"Error: Chemical symbol '{chem_symbol}' not found in the data."}
        
        # Filter data for the specified lat/long limits
        gdf = gdf[(gdf.geometry.y >= lat_limits[0]) & (gdf.geometry.y <= lat_limits[1]) & 
                  (gdf.geometry.x >= long_limits[0]) & (gdf.geometry.x <= long_limits[1])]
        
        if gdf.empty:
            return {"message": "Error: No data available within the specified lat/long limits."}
        
        # Calculate statistics of the chemical values
        chem_values = gdf[chem_symbol].values
        mean_value = np.mean(chem_values)
        mode_value = stats.mode(chem_values)
        median_value = np.median(chem_values)
        std_deviation = np.std(chem_values)
        variance = np.var(chem_values)
        data_count = len(chem_values)
        # Filter points with values higher than the threshold
        high_value_points = gdf[gdf[chem_symbol] > threshold]
        
        # Base map centered on the midpoint of the given lat/long limits
        lat_center = (lat_limits[0] + lat_limits[1]) / 2
        long_center = (long_limits[0] + long_limits[1]) / 2
        m = folium.Map(location=[lat_center, long_center], zoom_start=10, control_scale=True)
        
        # Add markers for high value points with tooltips
        for idx, row in high_value_points.iterrows():
            tooltip_text = (f'{chem_symbol}: {row[chem_symbol]:.2f} ppm<br>'
                            f'Coordinates: ({row.geometry.y:.6f}, {row.geometry.x:.6f})')
            folium.Marker(
                location=[row.geometry.y, row.geometry.x],
                tooltip=tooltip_text
            ).add_to(m)
        
        # Add layer control to toggle markers
        folium.LayerControl().add_to(m)
        # Add Measure Control with custom CSS to position it lower
        measure_control = MeasureControl()
        m.add_child(measure_control)
        
        measure_control_css = """
        <style>
        .leaflet-control-measure {
            top: 60px !important;  /* Adjust this value to move the control lower */
        }
        </style>
        """
        m.get_root().html.add_child(folium.Element(measure_control_css))


        north_arrow_svg = """
        <div style="position: fixed; 
                    top: 40px; right: 10px; width: 40px; height: 40px; 
                    z-index: 1000; pointer-events: none;">
                    <div style="margin-top:22px;">North</div>
            <svg version="1.1" id="icons" xmlns="http://www.w3.org/2000/svg" x="0" y="0" viewBox="0 0 128 128" style="enable-background:new 0 0 128 128" xml:space="preserve">
                <style>.st0,.st1{display:none;fill:#191919}.st1,.st3{fill-rule:evenodd;clip-rule:evenodd}.st3,.st4{display:inline;fill:#191919}</style>
                <g id="row1">
                    <path id="nav:2_3_" d="M64 1 17.9 127 64 99.8l46.1 27.2L64 1zm0 20.4 32.6 89.2L64 91.3V21.4z" style="fill:#191919"/>
                </g>
            </svg>
        </div>
        """
        m.get_root().html.add_child(folium.Element(north_arrow_svg))
        # Generate the HTML content
        html_content = m.get_root().render()
        
        # Construct the message with statistics
        message = f"Plotted points with '{chem_symbol}' values higher than {threshold:.2f} ppm\n"
        message += f"Mean: {mean_value:.2f} ppm\n"
        message += f"Mode: {mode_value} ppm\n"
        message += f"Median: {median_value:.2f} ppm\n"
        message += f"Standard Deviation: {std_deviation:.2f} ppm\n"
        message += f"Variance: {variance:.2f} ppm\n"
        message += f"Number of points: {data_count}\n"
        return {
            "message": message,
            "html": html_content
        }
    
    except Exception as e:
        return {"message": f"An error occurred: {str(e)}"}
    

def Manager_agent(query, lat_min, lat_max, long_min, long_max):
    lat_min = float(lat_min)
    lat_max = float(lat_max)
    long_min = float(long_min)
    long_max = float(long_max)
    chat_completion = client.chat.completions.create(
        #
        # Required parameters
        #
        messages=[
            # Set an optional system message. This sets the behavior of the
            # assistant and can be used to provide specific instructions for
            # how it should behave throughout the conversation.
            {
                "role": "system",
                "content": '''You are Khanij, an AI assistant for MECL (Mineral Exploration and Consultancy Limited).Your current knowledgebase has information of the following chemicals:
                            'sio2', 'al2o3', 'fe2o3', 'tio2', 'cao', 'mgo', 'mno', 'na2o', 'k2o', 'p2o5', 'loi', 'ba', 'ga', 'sc', 'v', 'th', 'pb', 'ni', 'co', 'rb', 'sr', 'y', 'zr', 'nb', 'cr', 'cu', 'zn', 'au', 'li', 'cs', 'as_', 'sb', 'bi', 'se', 'ag', 'be', 'ge', 'mo', 'sn', 'la', 'ce', 'pr', 'nd', 'sm', 'eu', 'tb', 'gd', 'dy', 'ho', 'er', 'tm', 'yb', 'lu', 'hf', 'ta', 'w', 'u', 'pt', 'pd'. You also have the elevation, gravity and magnetic values of regions of the nagpur region.
                            Based on the user query, determine the appropriate task to perform:
                            
                            - Print "Heatmap": If the query is related to creating a heatmap.
                            In the next line, print a Python list with one element: the chemical formula(not name) in lowercase mentioned in the query.
                            - If the query mentions geophysical magnetic data, Empty the list and add 'magnetic_a' to the list.
                            - If it's related to gravity,Empty the list and add 'bouguer_an' to the list.
                            - If it's related to elevation,Empty the list and add 'elevation_' to the list.
                            - Do not print anything else.

                            - Print "Threshold": If the query is related to finding all the points higher than a threshold.
                            In the next line, print a Python list with 2 elements: first: the chemical formula(not name) in lowercase mentioned in the query and second: the threshold value.

                            - Print "Contour": If the query is related to creating Interpolation contour maps.
                            In the next line, print a Python list with 2 elements: 1st, the chemical formula(not name) in lowercase mentioned in the query. and 2nd, add "1": if it is IDW(inverse distance weightage), "2": if it is Spline, "3": if it is Kriging, "4" if it is Nearest Neighbor.
                            - If the query mentions geophysical magnetic data,Replace the first element of list and add 'magnetic_a' to the list.
                            - If it's related to gravity,Replace the first element of list and add 'bouguer_an' to the list.
                            - If it's related to elevation,Replace the first element of list and add 'elevation_' to the list.
                            - Do not print anything else.

                            - Print "Exploration": If the query is about known exploration or excavation sites of the region.
                            In the next line, print "['Exploration']"
                            - Print "KrigingInterpolation": If the query is related to Kriging interpolation.
                            In the next line, print a Python list with one element: the chemical formula(not name) in lowercase mentioned in the query.
                            - If the query mentions geophysical magnetic data,Empty the list and add 'magnetic_a' to the list.
                            - If it's related to gravity,Empty the list and add 'bouguer_an' to the list.
                            - If it's related to elevation,Empty the list and add 'elevation_' to the list.
                            - Do not print anything else.

                            - Print "IDWInterpolation": If the query is related to IDW (Inverse Distance Weighting) interpolation.
                            In the next line, print a Python list with one element: the chemical formula(not name) in lowercase mentioned in the query.
                            - If the query mentions geophysical magnetic data,Empty the list and add 'magnetic_a' to the list.
                            - If it's related to gravity,Empty the list and add 'bouguer_an' to the list.
                            - If it's related to elevation,Empty the list and add 'elevation_' to the list.
                            - Do not print anything else.

                            - Print "SplineInterpolation": If the query is related to spline interpolation.
                            In the next line, print a Python list with one element: the chemical formula in lowercase mentioned in the query.
                            - If the query mentions geophysical magnetic data,Empty the list and add 'magnetic_a' to the list.
                            - If it's related to gravity,Empty the list and add 'bouguer_an' to the list.
                            - If it's related to elevation,Empty the list and add 'elevation_' to the list.
                            - Do not print anything else.

                            - Print "NNInterpolation": If the query is related to nearest neighbor interpolation.
                            In the next line, print a Python list with one element: the chemical formula(not the name) in lowercase mentioned in the query.
                            - If the query mentions geophysical magnetic data,Empty the list and add 'magnetic_a' to the list.
                            - If it's related to gravity,Empty the list and add 'bouguer_an' to the list.
                            - If it's related to elevation,Empty the list and add 'elevation_' to the list.
                            - Do not print anything else.

                            - Print "Histogram": If the query is related to creating a histogram.
                            In the next line, print a Python list of chemical formulas in lowercase of the chemicals mentioned in the query.
                            - If there are no chemicals mentioned, print a list containing the string 'all'.

                            - Print a response according to your knowledge: If the query does not relate to any of the specified tasks.
                            In the next line print ["No maps defined"]
                            '''
            },
            # Set a user message for the assistant to respond to.
            {
                "role": "user",
                "content": query,
            }
        ],

        # The language model which will generate the completion.
        model="llama3-70b-8192",

        #
        # Optional parameters
        #

        # Controls randomness: lowering results in less random completions.
        # As the temperature approaches zero, the model will become deterministic
        # and repetitive.
        temperature=0.5,

        # The maximum number of tokens to generate. Requests can use up to
        # 2048 tokens shared between prompt and completion.
        max_tokens=1024,

        # Controls diversity via nucleus sampling: 0.5 means half of all
        # likelihood-weighted options are considered.
        top_p=1,

        # A stop sequence is a predefined or user-specified text string that
        # signals an AI to stop generating content, ensuring its responses
        # remain focused and concise. Examples include punctuation marks and
        # markers like "[end]".
        stop=None,

        # If set, partial message deltas will be sent.
        stream=False,
    )

    #print(chat_completion.choices[0].message.content)

    response = chat_completion.choices[0].message.content
    lines = response.split('\n')
    task = lines[0]
    
    print(f"TASK: {task}")
    retval = {}
    if task == "Heatmap":
        par_list = eval(lines[1])
        print(par_list)
        column = par_list[0]
        if column == 'bouguer_an' or column== 'elevation_':
            retval= create_heatmap(gravity_file, column, lat_min, lat_max, long_min, long_max)
        elif column=='magnetic_a':
            retval= create_heatmap(magnetic_file, column, lat_min, lat_max, long_min, long_max)
        else:
            retval= create_heatmap(stream_sed_file, column, lat_min, lat_max, long_min, long_max)
    
    elif task== "Contour":
        
        par_list = eval(lines[1])
        print(par_list)
        column = par_list[0]
        method = int(par_list[1])
        if column == 'bouguer_an' or column== 'elevation_':
            retval= interpolation_contour(gravity_file, column, lat_min, lat_max, long_min, long_max, method)
        elif column=='magnetic_a':
            retval= interpolation_contour(magnetic_file, column, lat_min, lat_max, long_min, long_max, method)
        else:
            retval= interpolation_contour(stream_sed_file, column, lat_min, lat_max, long_min, long_max, method)
    
    elif task=="IDWInterpolation":
        par_list = eval(lines[1])
        print(par_list)
        column = par_list[0]
        if column == 'bouguer_an' or column== 'elevation_':
            retval= interpolation_geojson(gravity_file, column, lat_min, lat_max, long_min, long_max, 1)
        elif column=='magnetic_a':
            retval= interpolation_geojson(magnetic_file, column, lat_min, lat_max, long_min, long_max, 1)
        else:
            retval= interpolation_geojson(stream_sed_file, column, lat_min, lat_max, long_min, long_max, 1)
    
    elif task=="SplineInterpolation":
        par_list = eval(lines[1])
        print(par_list)
        column = par_list[0]
        if column == 'bouguer_an' or column== 'elevation_':
            retval= interpolation_geojson(gravity_file, column, lat_min, lat_max, long_min, long_max, 2)
        elif column=='magnetic_a':
            retval= interpolation_geojson(magnetic_file, column, lat_min, lat_max, long_min, long_max, 2)
        else:
            retval= interpolation_geojson(stream_sed_file, column, lat_min, lat_max, long_min, long_max, 2)
    
    elif task=="KrigingInterpolation":
        par_list = eval(lines[1])
        print(par_list)
        column = par_list[0]
        if column == 'bouguer_an' or column== 'elevation_':
            retval= interpolation_geojson(gravity_file, column, lat_min, lat_max, long_min, long_max, 3)
        elif column=='magnetic_a':
            retval= interpolation_geojson(magnetic_file, column, lat_min, lat_max, long_min, long_max, 3)
        else:
            retval= interpolation_geojson(stream_sed_file, column, lat_min, lat_max, long_min, long_max, 3)

    elif task=="NNInterpolation":
        par_list = eval(lines[1])
        print(par_list)
        column = par_list[0]
        if column == 'bouguer_an' or column== 'elevation_':
            retval= interpolation_geojson(gravity_file, column, lat_min, lat_max, long_min, long_max, 4)
        elif column=='magnetic_a':
            retval= interpolation_geojson(magnetic_file, column, lat_min, lat_max, long_min, long_max, 4)
        else:
            retval= interpolation_geojson(stream_sed_file, column, lat_min, lat_max, long_min, long_max, 4)
    
    elif task == "Threshold":
        par_list = eval(lines[1])
        print(par_list)
        column = par_list[0]
        threshold = float(par_list[1])
        retval= plot_high_value_points(stream_sed_file, column, lat_min, lat_max, long_min, long_max, threshold)
    
    
    elif task == "Exploration":
        retval=plot_excavation_sites(exploration_file, lat_min, lat_max, long_min, long_max)

    elif task == "Histogram":
        par_list = eval(lines[1])
        print(par_list)
        retval= create_geochem_avg_histogram(stream_sed_file,par_list, lat_min, lat_max, long_min, long_max)

    else:
        retval = {"message": response, "html": None}


    return retval








stream_sed_file = r'ngdr_json/stream_sediments_chem.geojson'
gravity_file = r'ngdr_json/gravity_phy.geojson'
magnetic_file = r'ngdr_json/magnetic_phy.geojson'
exploration_file = r'ngdr_json/exploration_data.geojson'
iface= gr.Interface(fn = Manager_agent,
                    inputs = ["text","text","text","text","text"],
                    outputs = "json",
                    title = "DataExplorer_Agent",
                    description="Gets Geological textual and visual outputs for a query")

iface.launch(inline=False)

# latmin = 21.0
# latmax = 22.0
# longmin = 78.0
# longmax = 79.0
# mquery = "Give the excavation sites in this reion"


# response = Manager_agent(mquery, latmin, latmax, longmin, longmax)

# if "html" in response:
#     with open('heatmap.html', 'w') as f:
#         f.write(response["html"])
#     print(response["message"])
# else:
#     print(response["message"])