import requests
import json

class BaserowAPI:
    def __init__(self, base_url, api_key, verbose=False):
        self.base_url = base_url
        self.api_key = api_key
        self.verbose = verbose

    def create_headers(self):
        """Create headers for API requests."""
        return {
            "Authorization": f"Token {self.api_key}",
            "Content-Type": "application/json"
        }

    def handle_api_response(self, response):
        """Handle API response, check for errors and decode JSON."""
        if self.verbose:
            print("[INFO] Handling API response...")
            print("Response Status Code:", response.status_code)
            print("Response Headers:", response.headers)
        if response.status_code != 200:
            print(f"Error: Received status code {response.status_code} from Baserow API.")
            print("Response content:", response.content.decode())
            return None

        try:
            return response.json()
        except requests.RequestsJSONDecodeError:
            print("Error: Failed to decode the response as JSON.")
            return None

    def get_all_rows_from_table(self, table_id):
        if self.verbose:
            print(f"[INFO] Fetching all rows from table with ID: {table_id}...")
        headers = self.create_headers()
        rows = []
        next_url = f"{self.base_url}database/rows/table/{table_id}/"

        while next_url:
            response = requests.get(next_url, headers=headers)
            if self.verbose:
                print("Headers:", headers)
                print("Requesting:", next_url)
            data = self.handle_api_response(response)
            if not data:
                break
            rows.extend(data['results'])
            next_url = data['next']

        return rows

    def get_all_tables_from_database(self, database_id):
        if self.verbose:
            print(f"[INFO] Fetching all tables from database with ID: {database_id}...")
        headers = self.create_headers()
        response = requests.get(f"{self.base_url}database/tables/database/{database_id}/", headers=headers)
        if self.verbose:
            print("Headers:", headers)
        return self.handle_api_response(response) or []

    def get_all_data_from_database(self, database_id):
        if self.verbose:
            print(f"[INFO] Fetching all data from database with ID: {database_id}...")
        tables = self.get_all_tables_from_database(database_id)
        data = {}

        for table in tables:
            table_id = table['id']
            table_name = table['name']
            data[table_name] = self.get_all_rows_from_table(table_id)

        return data

    def fetch_fields_for_table(self, table_id):
        """Fetch fields for a given table."""
        headers = self.create_headers()
        response = requests.get(f"{self.base_url}database/fields/table/{table_id}/", headers=headers)
        if response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"Failed to fetch fields for table {table_id}. Status code: {response.status_code}")

    def merge_tables_on_reference(self, tables_data):
        if self.verbose:
            print("Merging tables based on references...")

        # Create a mapping of table names to their rows indexed by ID
        indexed_data = {table_name: {row['id']: row for row in rows} for table_name, rows in tables_data.items()}
        if self.verbose:
            print("Indexed Data:", indexed_data)

        # Fetch field information for each table and identify link fields
        link_fields = {}
        for table_name in tables_data:
            fields = self.fetch_fields_for_table(table_name)
            link_fields_for_table = [field for field in fields if field['type'] == 'link_row']
            link_fields[table_name] = link_fields_for_table
        if self.verbose:
            print("Link Fields:", link_fields)
            print("Link Fields For Table:", link_fields_for_table)

        # Embed referenced data into tables
        for table_name, rows in tables_data.items():
            for row in rows:
                for link_field in link_fields[table_name]:
                    field_name = link_field['name']
                    referenced_table_id = link_field['link_row_table_id']
                    if field_name in row and row[field_name] in indexed_data[referenced_table_id]:
                        if self.verbose:
                            print(f"Embedding referenced data for field {field_name} in table {table_name}")
                        row[field_name] = indexed_data[referenced_table_id][row[field_name]]

        if self.verbose:
            print("Merged Tables Data:", tables_data)
        return tables_data