# Sisense API integration
import requests
import json
from datetime import datetime, timedelta

class SisenseAPI:
    def __init__(self, server_url, username, password):
        self.server_url = server_url.rstrip('/')
        self.session = requests.Session()
        self.authenticate(username, password)
    
    def authenticate(self, username, password):
        """Authenticate with Sisense server"""
        auth_data = {
            'username': username,
            'password': password
        }
        
        response = self.session.post(
            f"{self.server_url}/api/v1/authentication/login",
            json=auth_data
        )
        
        if response.status_code == 200:
            # Token automatically stored in session cookies
            print("Authentication successful")
        else:
            raise Exception(f"Authentication failed: {response.text}")
    
    def create_elasticube(self, cube_name, data_sources):
        """Create new ElastiCube with data sources"""
        cube_config = {
            'title': cube_name,
            'datasources': data_sources
        }
        
        response = self.session.post(
            f"{self.server_url}/api/v1/elasticubes",
            json=cube_config
        )
        
        return response.json()
    
    def query_data(self, cube_name, query_config):
        """Execute query against ElastiCube"""
        query_data = {
            'datasource': cube_name,
            'metadata': query_config['metadata'],
            'query': query_config['query']
        }
        
        response = self.session.post(
            f"{self.server_url}/api/datasources/{cube_name}/sql",
            json=query_data
        )
        
        return response.json()
    
    def create_dashboard(self, title, widgets, cube_name):
        """Create new dashboard with widgets"""
        dashboard_config = {
            'title': title,
            'datasource': cube_name,
            'widgets': widgets,
            'layout': {
                'columns': [
                    {'width': 50, 'cells': [{'height': 400, 'widgetid': widgets[0]['oid']}]},
                    {'width': 50, 'cells': [{'height': 400, 'widgetid': widgets[1]['oid']}]}
                ]
            }
        }
        
        response = self.session.post(
            f"{self.server_url}/api/v1/dashboards",
            json=dashboard_config
        )
        
        return response.json()
    
    def get_ai_insights(self, cube_name, table_name):
        """Get AI-generated insights for data"""
        insights_request = {
            'datasource': cube_name,
            'table': table_name,
            'insights_type': 'auto_insights'
        }
        
        response = self.session.post(
            f"{self.server_url}/api/v1/ai/insights",
            json=insights_request
        )
        
        return response.json()

# Usage example
sisense = SisenseAPI('https://your-sisense-server.com', 'username', 'password')

# Create ElastiCube with multiple data sources
data_sources = [
    {
        'type': 'postgresql',
        'connection': 'server=localhost;database=sales;',
        'tables': ['orders', 'customers', 'products']
    },
    {
        'type': 'csv',
        'path': '/data/marketing_campaigns.csv'
    }
]

cube = sisense.create_elasticube('sales_analytics', data_sources)
print(f"Created ElastiCube: {cube['title']}")

# Get AI insights
insights = sisense.get_ai_insights('sales_analytics', 'orders')
print("AI Insights discovered:", insights)

// Sisense embedded analytics
class SisenseEmbedded {
    constructor(sisenseUrl, token) {
        this.sisenseUrl = sisenseUrl;
        this.token = token;
        this.loadSisenseSDK();
    }
    
    loadSisenseSDK() {
        const script = document.createElement('script');
        script.src = `${this.sisenseUrl}/js/sisense.v1.js`;
        script.onload = () => {
            this.sisense = Sisense.connect(this.sisenseUrl);
            this.sisense.authenticate(this.token);
        };
        document.head.appendChild(script);
    }
    
    embedDashboard(dashboardId, containerId, filters = {}) {
        const container = document.getElementById(containerId);
        
        const dashboard = this.sisense.embed({
            type: 'dashboard',
            id: dashboardId,
            container: container,
            options: {
                filters: filters,
                showToolbar: true,
                showLeftPane: false
            }
        });
        
        dashboard.on('ready', () => {
            console.log('Dashboard embedded successfully');
        });
        
        dashboard.on('filterschange', (e, filters) => {
            console.log('Dashboard filters changed:', filters);
            this.onFiltersChange(filters);
        });
        
        return dashboard;
    }
    
    embedWidget(widgetId, containerId, customization = {}) {
        const container = document.getElementById(containerId);
        
        const widget = this.sisense.embed({
            type: 'widget',
            id: widgetId,
            container: container,
            options: {
                ...customization,
                showToolbar: false
            }
        });
        
        return widget;
    }
    
    createCustomVisualization(queryConfig, containerId) {
        const container = document.getElementById(containerId);
        
        // Custom query execution
        this.sisense.query(queryConfig)
            .then(data => {
                // Custom D3.js or Chart.js visualization
                this.renderCustomChart(data, container);
            })
            .catch(error => {
                console.error('Query execution failed:', error);
            });
    }
    
    renderCustomChart(data, container) {
        // Example using Chart.js for custom visualization
        const ctx = container.getContext('2d');
        
        new Chart(ctx, {
            type: 'scatter',
            data: {
                datasets: [{
                    label: 'Custom Analytics',
                    data: data.map(row => ({
                        x: row.revenue,
                        y: row.profit_margin
                    })),
                    backgroundColor: 'rgba(54, 162, 235, 0.2)',
                    borderColor: 'rgba(54, 162, 235, 1)'
                }]
            },
            options: {
                responsive: true,
                scales: {
                    x: {
                        type: 'linear',
                        position: 'bottom',
                        title: {
                            display: true,
                            text: 'Revenue'
                        }
                    },
                    y: {
                        title: {
                            display: true,
                            text: 'Profit Margin %'
                        }
                    }
                }
            }
        });
    }
    
    onFiltersChange(filters) {
        // Propagate filter changes to other embedded components
        this.updateRelatedWidgets(filters);
    }
    
    updateRelatedWidgets(filters) {
        // Update other widgets based on filter changes
        console.log('Updating related widgets with filters:', filters);
    }
}

// Usage
const sisenseEmbed = new SisenseEmbedded('https://your-sisense.com', 'your-auth-token');

// Embed complete dashboard
const dashboard = sisenseEmbed.embedDashboard(
    'dashboard-123',
    'dashboard-container',
    { 'Category': 'Electronics', 'Date': 'Last 30 Days' }
);

// Embed individual widget
const revenueWidget = sisenseEmbed.embedWidget(
    'widget-456',
    'revenue-widget-container',
    {
        title: 'Monthly Revenue Trends',
        showHeader: true
    }
);

// Natural language to SQL with Sisense AI
class SisenseAIInterface {
    constructor(sisenseAPI) {
        this.api = sisenseAPI;
        this.setupNLPInterface();
    }
    
    setupNLPInterface() {
        const queryInput = document.getElementById('natural-language-query');
        const submitBtn = document.getElementById('submit-query');
        const resultsDiv = document.getElementById('query-results');
        
        submitBtn.addEventListener('click', () => {
            const naturalQuery = queryInput.value;
            this.processNaturalLanguageQuery(naturalQuery, resultsDiv);
        });
    }
    
    async processNaturalLanguageQuery(query, resultsContainer) {
        try {
            // Convert natural language to Sisense query
            const sisenseQuery = await this.convertNLToQuery(query);
            
            // Execute query
            const results = await this.api.executeQuery(sisenseQuery);
            
            // Display results with AI insights
            this.displayResultsWithInsights(results, resultsContainer);
            
        } catch (error) {
            console.error('Query processing failed:', error);
            resultsContainer.innerHTML = `<p class="error">Query failed: ${error.message}</p>`;
        }
    }
    
    async convertNLToQuery(naturalLanguage) {
        // Sisense AI NLP processing
        const nlpRequest = {
            query: naturalLanguage,
            context: 'sales_analytics', // ElastiCube context
            include_suggestions: true
        };
        
        const response = await fetch('/api/sisense/nlp/convert', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(nlpRequest)
        });
        
        return response.json();
    }
    
    displayResultsWithInsights(results, container) {
        // Create results visualization
        const visualization = this.createVisualization(results.data);
        
        // Add AI insights
        const insights = this.generateInsights(results.data);
        
        container.innerHTML = `
            <div class="query-results">
                <div class="visualization">${visualization}</div>
                <div class="ai-insights">
                    <h3>AI Insights</h3>
                    <ul>
                        ${insights.map(insight => `<li>${insight}</li>`).join('')}
                    </ul>
                </div>
            </div>
        `;
    }
    
    createVisualization(data) {
        // Auto-select best visualization based on data structure
        const chartType = this.suggestChartType(data);
        return this.renderChart(data, chartType);
    }
    
    suggestChartType(data) {
        // AI-based chart type suggestion
        const columnCount = Object.keys(data[0]).length;
        const hasTimeColumn = Object.keys(data[0]).some(key => 
            key.toLowerCase().includes('date') || key.toLowerCase().includes('time')
        );
        
        if (hasTimeColumn && columnCount === 2) return 'line';
        if (columnCount === 2) return 'bar';
        if (columnCount > 2) return 'scatter';
        
        return 'table';
    }
    
    generateInsights(data) {
        const insights = [];
        
        // Example AI insights generation
        if (data.length > 0) {
            const numericColumns = Object.keys(data[0]).filter(key => 
                typeof data[0][key] === 'number'
            );
            
            numericColumns.forEach(column => {
                const values = data.map(row => row[column]);
                const avg = values.reduce((a, b) => a + b) / values.length;
                const max = Math.max(...values);
                const min = Math.min(...values);
                
                insights.push(`Average ${column}: ${avg.toFixed(2)}`);
                insights.push(`${column} ranges from ${min} to ${max}`);
                
                // Trend analysis
                if (values.length > 1) {
                    const trend = values[values.length - 1] > values[0] ? 'increasing' : 'decreasing';
                    insights.push(`${column} shows ${trend} trend`);
                }
            });
        }
        
        return insights;
    }
}

// Initialize AI interface
const aiInterface = new SisenseAIInterface(sisenseAPI);