import streamlit as st
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import requests
import json
import io

# Konfiguracja
st.set_page_config(page_title="🤖 DataSense Agent", layout="wide")

st.title("🤖 DataSense Agent")
st.write("Agent analityczny")

# Session state
if 'df' not in st.session_state:
    st.session_state.df = None
if 'file_info' not in st.session_state:
    st.session_state.file_info = None
if 'analysis_history' not in st.session_state:
    st.session_state.analysis_history = []
if 'questions_count' not in st.session_state:
    st.session_state.questions_count = 0
if 'quick_question' not in st.session_state:
    st.session_state.quick_question = ""

# API
DEEPSEEK_API_URL = "https://api.deepseek.com/v1/chat/completions"

def smart_csv_detection(file_content):
    """Inteligentne wykrywanie formatu CSV"""
    separators = [';', ',', '\t', '|']
    encodings = ['utf-8', 'cp1250', 'latin1', 'iso-8859-1']
    
    st.info("🔍 Analizuję format pliku...")
    
    try:
        sample_text = None
        for encoding in encodings:
            try:
                file_content.seek(0)
                sample_text = file_content.read(2000).decode(encoding, errors='ignore')
                break
            except:
                continue
        
        if not sample_text:
            return None, "Nie można określić kodowania pliku"
        
        file_content.seek(0)
        
    except Exception as e:
        return None, f"Błąd odczytu pliku: {e}"
    
    results = []
    
    for separator in separators:
        for encoding in encodings:
            try:
                file_content.seek(0)
                
                test_df = pd.read_csv(
                    file_content,
                    sep=separator,
                    encoding=encoding,
                    nrows=5,
                    quotechar='"',
                    skipinitialspace=True,
                    on_bad_lines='skip'
                )
                
                num_cols = len(test_df.columns)
                quality_score = 0
                
                if num_cols > 1:
                    quality_score += num_cols * 10
                
                problematic_names = sum(1 for col in test_df.columns if ';' in str(col) or ',' in str(col))
                quality_score -= problematic_names * 50
                
                if num_cols > 1 and len(test_df) > 0:
                    first_row = test_df.iloc[0]
                    valid_cells = sum(1 for val in first_row if pd.notna(val) and str(val).strip())
                    quality_score += valid_cells * 5
                
                results.append({
                    'separator': separator,
                    'encoding': encoding,
                    'columns': num_cols,
                    'quality': quality_score,
                    'sample_df': test_df,
                    'column_names': list(test_df.columns)
                })
                
            except Exception as e:
                continue
    
    if not results:
        return None, "Nie udało się wykryć formatu pliku"
    
    best_result = max(results, key=lambda x: x['quality'])
    
    st.success(f"✅ Wykryty format:")
    st.write(f"**Separator:** '{best_result['separator']}'")
    st.write(f"**Kodowanie:** {best_result['encoding']}")
    st.write(f"**Kolumny:** {best_result['columns']}")
    st.write(f"**Jakość:** {best_result['quality']} punktów")
    
    if len(results) > 1:
        with st.expander("🔧 Inne możliwe formaty", expanded=False):
            for i, result in enumerate(sorted(results, key=lambda x: x['quality'], reverse=True)[:3]):
                if result != best_result:
                    st.write(f"Opcja {i+1}: separator='{result['separator']}', kodowanie={result['encoding']}, kolumny={result['columns']}")
    
    return best_result, None

def load_csv_with_config(file_content, config):
    """Wczytaj pełny CSV z wykrytą konfiguracją"""
    try:
        file_content.seek(0)
        
        df = pd.read_csv(
            file_content,
            sep=config['separator'],
            encoding=config['encoding'],
            quotechar='"',
            skipinitialspace=True,
            on_bad_lines='skip'
        )
        
        return df, None
        
    except Exception as e:
        return None, f"Błąd wczytywania: {e}"

def safe_display_data(df, max_rows=5):
    """Bezpieczne wyświetlanie danych"""
    try:
        if len(df) <= max_rows:
            st.dataframe(df, use_container_width=True)
        else:
            st.dataframe(df.head(max_rows), use_container_width=True)
            st.info(f"Pokazano {max_rows} z {len(df)} wierszy")
    except:
        st.warning("⚠️ Problem z wyświetlaniem tabeli. Pokazuję jako tekst:")
        for i in range(min(max_rows, len(df))):
            row_data = []
            for col in df.columns[:6]:
                try:
                    val = df.iloc[i][col]
                    row_data.append(f"{col}: {val}")
                except:
                    row_data.append(f"{col}: [błąd]")
            st.text(f"Wiersz {i+1}: {' | '.join(row_data)}")

def generate_interpretation(question, result, code, api_key):
    """Generuje interpretację wyników przez AI"""
    if not api_key:
        return "⚠️ Brak klucza API - interpretacja niedostępna"
    
    prompt = f"""
    Jako ekspert analizy danych, przygotuj zwięzłą interpretację wyników w języku polskim:

    Pytanie użytkownika: {question}
    Wynik analizy: {str(result)[:800] if result is not None else "Brak wyniku"}
    Użyty kod: {code}

    Przygotuj interpretację w formacie:
    
    ## 📊 Podsumowanie
    [1-2 zdania o głównym wyniku]
    
    ## 🔍 Kluczowe wnioski
    - [Wniosek 1]
    - [Wniosek 2] 
    - [Wniosek 3 jeśli jest]
    
    ## 💡 Sugestie dalszych analiz
    [Konkretne pomysły na kolejne pytania]
    
    Bądź konkretny i praktyczny. Używaj prostego języka.
    """
    
    try:
        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
        payload = {
            "model": "deepseek-chat",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.4,
            "max_tokens": 600
        }
        
        response = requests.post(DEEPSEEK_API_URL, headers=headers, json=payload, timeout=30)
        
        if response.status_code == 200:
            return response.json()['choices'][0]['message']['content']
        else:
            return f"❌ Błąd API interpretacji: {response.status_code}"
            
    except Exception as e:
        return f"❌ Błąd interpretacji: {str(e)}"

def simple_query_ai(prompt, api_key):
    """Zapytanie do AI"""
    if not api_key:
        return None
        
    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
    payload = {
        "model": "deepseek-chat",
        "messages": [{"role": "user", "content": prompt}],
        "temperature": 0.3,
        "max_tokens": 800
    }
    
    try:
        response = requests.post(DEEPSEEK_API_URL, headers=headers, json=payload, timeout=30)
        if response.status_code == 200:
            return response.json()['choices'][0]['message']['content']
        else:
            st.error(f"API Error: {response.status_code}")
            return None
    except Exception as e:
        st.error(f"Connection error: {e}")
        return None

def extract_python_code(text):
    """Wyciągnij kod Python"""
    if "```python" in text:
        start = text.find("```python") + 9
        end = text.find("```", start)
        return text[start:end].strip()
    elif "```" in text:
        start = text.find("```") + 3
        end = text.find("```", start)
        return text[start:end].strip()
    else:
        return text.strip()

def safe_execute_code(code, df):
    """Wykonaj kod bezpiecznie z szczegółowymi logami"""
    
    # Logi wykonania
    st.subheader("🔍 Logi wykonania:")
    log_container = st.container()
    
    with log_container:
        st.write("**Krok 1:** Sprawdzanie bezpieczeństwa kodu...")
        
        # Usuń problematyczne linijki
        problematic_patterns = ['read_csv', 'pd.read', 'pandas.read', 'to_csv', 'read_excel', 'open(', 'file(']
        lines = code.split('\n')
        clean_lines = []
        removed_lines = []
        
        for line in lines:
            if not any(pattern in line for pattern in problematic_patterns):
                clean_lines.append(line)
            else:
                removed_lines.append(line.strip())
        
        if removed_lines:
            st.warning(f"🛡️ Usunięto {len(removed_lines)} potencjalnie niebezpiecznych linijek:")
            for line in removed_lines:
                st.code(line, language='python')
        else:
            st.success("✅ Kod jest bezpieczny")
        
        cleaned_code = '\n'.join(clean_lines)
        
        st.write("**Krok 2:** Przygotowanie środowiska wykonania...")
        
        # Bezpieczne środowisko z matplotlib
        safe_globals = {
            'pd': pd,
            'np': np,
            'plt': plt,
            'df': df,
            'len': len,
            'sum': sum,
            'max': max,
            'min': min,
            'abs': abs,
            'round': round,
            'str': str,
            'int': int,
            'float': float,
            'list': list,
            'dict': dict,
            'sorted': sorted,
            'enumerate': enumerate,
            'range': range
        }
        
        st.success(f"✅ Dostępne moduły: pd, np, plt, df")
        
        st.write("**Krok 3:** Wykonywanie kodu...")
        
        safe_locals = {'result': None, 'fig': None}
        
        try:
            # Wykonaj cały kod naraz (bezpieczniej dla wielolinijkowych struktur)
            progress_bar = st.progress(0)
            progress_bar.progress(0.3)
            
            # Spróbuj wykonać cały kod
            exec(cleaned_code, safe_globals, safe_locals)
            
            progress_bar.progress(1.0)
            st.success("✅ Kod wykonany pomyślnie")
            
            # Sprawdź co zostało utworzone
            result = safe_locals.get('result')
            fig = safe_locals.get('fig')
            
            st.write("**Krok 4:** Sprawdzenie wyników...")
            
            if result is not None:
                result_type = type(result).__name__
                if hasattr(result, 'shape'):
                    st.info(f"📊 Wynik: {result_type} o rozmiarze {result.shape}")
                else:
                    st.info(f"📊 Wynik: {result_type}")
            else:
                st.warning("⚠️ Brak wyniku w zmiennej 'result'")
            
            if fig is not None:
                st.success("📈 Wykres został utworzony")
            
            # Sprawdź czy matplotlib ma aktywne figury
            if plt.get_fignums():
                if fig is None:
                    fig = plt.gcf()  # Pobierz aktualną figurę
                st.info("📈 Wykrywam wykres matplotlib")
            
            return result, fig, None
            
        except Exception as e:
            st.error(f"❌ Błąd wykonania: {str(e)}")
            return None, None, str(e)

# Sidebar
with st.sidebar:
    st.header("⚙️ Konfiguracja")
    api_key = st.text_input("🔑 DeepSeek API Key", type="password")
    
    st.header("📁 Upload pliku")
    uploaded_file = st.file_uploader("Wybierz plik CSV", type=['csv', 'txt'])
    
    if uploaded_file:
        st.info("📋 Aplikacja automatycznie wykryje format pliku")
        
        # Opcja ręcznego wyboru
        manual_override = st.checkbox("🔧 Ręczne ustawienia (zaawansowane)")
        
        if manual_override:
            manual_sep = st.selectbox("Separator", [';', ',', '\t', '|'])
            manual_enc = st.selectbox("Kodowanie", ['utf-8', 'cp1250', 'latin1'])
            st.session_state.manual_config = {
                'separator': manual_sep,
                'encoding': manual_enc,
                'columns': 0,
                'quality': 0,
                'sample_df': None,
                'column_names': []
            }
    
    # Historia i szybkie pytania
    if st.session_state.df is not None:
        st.header("📊 Szybkie pytania")
        
        # Podstawowe pytania
        if st.button("📏 Ile wierszy?"):
            st.session_state.quick_question = "Ile jest wierszy w danych?"
        if st.button("📋 Jakie kolumny?"):
            st.session_state.quick_question = "Pokaż nazwy wszystkich kolumn"
        if st.button("🔢 Statystyki"):
            st.session_state.quick_question = "Pokaż podstawowe statystyki numeryczne"
        
        # Szybkie wykresy
        st.subheader("📈 Szybkie wykresy")
        numeric_cols = st.session_state.df.select_dtypes(include=[np.number]).columns
        categorical_cols = st.session_state.df.select_dtypes(include=['object']).columns
        
        if len(numeric_cols) > 0:
            if st.button("📊 Histogram pierwszej kolumny"):
                first_numeric = numeric_cols[0]
                st.session_state.quick_question = f"Stwórz histogram dla kolumny {first_numeric}"
        
        if len(categorical_cols) > 0:
            if st.button("📈 Wykres kategorii"):
                first_categorical = categorical_cols[0]
                st.session_state.quick_question = f"Stwórz wykres słupkowy pokazujący ile jest każdej kategorii w kolumnie {first_categorical}"
        
        if len(numeric_cols) >= 2:
            if st.button("🔍 Scatter plot"):
                col1, col2 = numeric_cols[0], numeric_cols[1]
                st.session_state.quick_question = f"Stwórz scatter plot dla kolumn {col1} i {col2}"
        
        # Historia
        if st.session_state.analysis_history:
            st.header("📜 Historia")
            st.write(f"Wykonanych analiz: **{len(st.session_state.analysis_history)}**")
            
            # Ostatnie pytanie z info o wykresie
            if st.session_state.analysis_history:
                last = st.session_state.analysis_history[-1]
                st.write("**Ostatnie pytanie:**")
                st.write(f"_{last['question'][:50]}..._")
                if last.get('has_plot', False):
                    st.write("📈 *Zawierało wykres*")
            
            # Statystyki historii
            total_plots = sum(1 for analysis in st.session_state.analysis_history if analysis.get('has_plot', False))
            st.write(f"**Wykresy utworzone:** {total_plots}")
            
            # Najczęstsze słowa kluczowe
            all_questions = [analysis['question'].lower() for analysis in st.session_state.analysis_history]
            common_words = []
            for question in all_questions:
                if 'balans' in question: common_words.append('balans')
                if 'wykres' in question or 'histogram' in question: common_words.append('wykresy')
                if 'średnia' in question: common_words.append('średnie')
                if 'top' in question: common_words.append('rankingi')
            
            if common_words:
                unique_words = list(set(common_words))
                st.write(f"**Popularne tematy:** {', '.join(unique_words)}")

# Main interface
col1, col2 = st.columns([3, 1])

with col1:
    if uploaded_file and st.button("🚀 WCZYTAJ I ANALIZUJ PLIK", type="primary"):
        with st.spinner("🔍 Analizuję format pliku..."):
            
            # Sprawdź czy użytkownik wybrał ręczne ustawienia
            if hasattr(st.session_state, 'manual_config') and st.session_state.get('manual_override', False):
                config = st.session_state.manual_config
                st.info("🔧 Używam ręcznych ustawień")
            else:
                # Automatyczne wykrywanie
                config, error = smart_csv_detection(uploaded_file)
                
                if error:
                    st.error(f"❌ {error}")
                    st.stop()
            
            # Wczytaj pełny plik
            with st.spinner("📊 Wczytuję dane..."):
                df, error = load_csv_with_config(uploaded_file, config)
                
                if error:
                    st.error(f"❌ {error}")
                    st.stop()
                
                st.session_state.df = df
                st.session_state.file_info = config
                
                # Pokaż wyniki
                st.success(f"✅ SUKCES! Wczytano {df.shape[0]:,} wierszy × {df.shape[1]} kolumn")
                
                # Info o kolumnach
                st.write("📋 **Kolumny:**")
                col_info = []
                for i, col in enumerate(df.columns):
                    dtype = str(df[col].dtype)
                    non_null = df[col].count()
                    col_info.append(f"{i+1}. **{col}** ({dtype}) - {non_null:,}/{len(df):,} wartości")
                
                # Pokaż kolumny w kolumnach dla czytelności
                col_chunks = [col_info[i:i+3] for i in range(0, len(col_info), 3)]
                for chunk in col_chunks:
                    cols = st.columns(len(chunk))
                    for i, info in enumerate(chunk):
                        cols[i].write(info)
                
                # Podgląd danych
                st.write("📄 **Podgląd danych:**")
                safe_display_data(df)
    
    # Sekcja analizy
    if st.session_state.df is not None:
        st.header("🔍 Analiza danych")
        
        df = st.session_state.df
        
        # Pokaż historię analiz jeśli są
        if st.session_state.analysis_history:
            with st.expander(f"📜 Historia analiz ({len(st.session_state.analysis_history)})", expanded=False):
                for i, analysis in enumerate(reversed(st.session_state.analysis_history[-5:])):  # Ostatnie 5
                    idx = len(st.session_state.analysis_history) - i
                    st.write(f"**{idx}. {analysis['question']}**")
                    
                    # Ikona wykresu jeśli był
                    if analysis.get('has_plot', False):
                        st.write("📈 *Zawierał wykres*")
                    
                    # Krótki wynik
                    result_preview = str(analysis['result'])[:100]
                    if len(str(analysis['result'])) > 100:
                        result_preview += "..."
                    st.write(f"Wynik: {result_preview}")
                    
                    # Timestamp
                    if 'timestamp' in analysis:
                        st.caption(f"⏰ {analysis['timestamp'].strftime('%H:%M:%S')}")
                    
                    st.write("---")
        
        # Formularz do pytań
        with st.form("analysis_form", clear_on_submit=True):
            # Sprawdź czy jest szybkie pytanie
            default_question = ""
            if hasattr(st.session_state, 'quick_question') and st.session_state.quick_question:
                default_question = st.session_state.quick_question
                st.session_state.quick_question = ""
            
            question = st.text_area(
                "💬 Zadaj pytanie o dane:",
                height=100,
                placeholder="np. Histogram balansu, Top 10 zawodów, Rozkład wieku klientów",
                key=f"question_input_{st.session_state.questions_count}",
                value=default_question
            )
            
            col_btn1, col_btn2 = st.columns(2)
            with col_btn1:
                submit_button = st.form_submit_button("🧠 ANALIZUJ", type="primary")
            with col_btn2:
                clear_history = st.form_submit_button("🗑️ Wyczyść historię")
        
        # Wyczyść historię jeśli kliknięto
        if clear_history:
            st.session_state.analysis_history = []
            st.success("✅ Historia wyczyszczona")
            st.rerun()
        
        # Przetwórz pytanie
        if submit_button and api_key and question.strip():
            st.session_state.questions_count += 1
            
            # Przygotuj informacje o danych
            columns_info = f"Kolumny: {', '.join(df.columns)}"
            dtypes_info = f"Typy danych: {dict(df.dtypes)}"
            
            sample_data = []
            for col in df.columns[:8]:  # Pierwsze 8 kolumn
                try:
                    if df[col].dtype in ['object', 'string']:
                        unique_vals = df[col].dropna().unique()[:3]
                        sample_data.append(f"{col}: {list(unique_vals)}")
                    else:
                        stats = f"min={df[col].min()}, max={df[col].max()}, średnia={df[col].mean():.2f}"
                        sample_data.append(f"{col}: {stats}")
                except:
                    sample_data.append(f"{col}: [błąd próbkowania]")
            
            sample_info = "Przykładowe dane: " + " | ".join(sample_data)
            
            # Prompt dla AI z zachętą do tworzenia wykresów
            prompt = f"""
Odpowiedz na pytanie o dane używając kodu Python. WAŻNE: Jeśli pytanie może być lepiej zobrazowane wykresem, stwórz go!

PYTANIE: {question}

INFORMACJE O DANYCH:
{columns_info}
{dtypes_info}
Rozmiar: {df.shape[0]} wierszy × {df.shape[1]} kolumn
{sample_info}

ZASADY:
1. DataFrame nazywa się 'df' i jest już załadowany
2. NIE używaj pd.read_csv(), pd.read_excel() ani podobnych
3. Wynik zapisz w zmiennej 'result'
4. Używaj pandas, numpy, matplotlib (plt)
5. Kod ma być prosty i skuteczny
6. WYKRES: Jeśli pytanie dotyczy rozkładów, trendów, porównań - ZAWSZE utwórz wykres w zmiennej 'fig'

KIEDY TWORZYĆ WYKRESY:
- Rozkłady wartości → histogram: plt.hist()
- Porównania kategorii → wykres słupkowy: plt.bar()
- Trendy w czasie → wykres liniowy: plt.plot()
- Korelacje → scatter plot: plt.scatter()
- Top N → wykres słupkowy
- Statystyki grupowe → wykres słupkowy lub pudełkowy

PRZYKŁADY KODÓW Z WYKRESAMI:

# Histogram rozkładu
result = df['balance'].describe()
fig, ax = plt.subplots(figsize=(10, 6))
ax.hist(df['balance'], bins=30, alpha=0.7)
ax.set_title('Rozkład balansu klientów')
ax.set_xlabel('Balans')
ax.set_ylabel('Liczba klientów')

# Wykres słupkowy dla kategorii  
result = df['job'].value_counts().head(10)
fig, ax = plt.subplots(figsize=(12, 6))
result.plot(kind='bar', ax=ax)
ax.set_title('Top 10 zawodów')
ax.set_xlabel('Zawód')
ax.set_ylabel('Liczba osób')
plt.xticks(rotation=45)

# Porównanie grup
result = df.groupby('job')['balance'].mean().head(10)
fig, ax = plt.subplots(figsize=(12, 6))
result.plot(kind='bar', ax=ax)
ax.set_title('Średni balans według zawodu')
ax.set_ylabel('Średni balans')
plt.xticks(rotation=45)

PRZYKŁADY BEZ WYKRESÓW (tylko liczby):
- Liczba wierszy: result = len(df)
- Średnia: result = df['kolumna'].mean()
- Filtrowanie: result = len(df[df['kolumna'] > 100])

Zwróć TYLKO kod Python (bez wyjaśnień):
"""

            # Zapytaj AI
            with st.spinner("🤖 AI generuje kod..."):
                st.info("🔄 Wysyłam zapytanie do DeepSeek API...")
                ai_response = simple_query_ai(prompt, api_key)
            
            if ai_response:
                st.success("✅ Otrzymano odpowiedź od AI")
                code = extract_python_code(ai_response)
                
                st.subheader("🔧 Wygenerowany kod:")
                st.code(code, language='python')
                
                # Wykonaj z logowaniem
                with st.spinner("⚡ Wykonuję analizę..."):
                    result, fig, error = safe_execute_code(code, df)
                
                # Wyniki
                if error:
                    st.error(f"❌ Błąd końcowy: {error}")
                    st.write("**Możliwe rozwiązania:**")
                    st.write("- Sprawdź nazwy kolumn")
                    st.write("- Upewnij się że kolumna zawiera dane liczbowe")
                    st.write("- Spróbuj prostsze pytanie")
                else:
                    st.subheader("📊 WYNIK:")
                    if result is not None:
                        if isinstance(result, (int, float)):
                            st.metric("Wynik", f"{result:,}")
                        elif isinstance(result, str):
                            st.write(f"**{result}**")
                        elif isinstance(result, pd.DataFrame):
                            st.write("**Tabela wyników:**")
                            safe_display_data(result, max_rows=20)
                        elif isinstance(result, pd.Series):
                            st.write("**Serie danych:**")
                            safe_display_data(result.to_frame(), max_rows=20)
                        else:
                            st.write("**Wynik:**")
                            st.text(str(result)[:1000])
                    
                    # WYKRESY - ulepszone wyświetlanie
                    if fig is not None:
                        st.subheader("📈 Wykres:")
                        try:
                            plt.tight_layout()
                            st.pyplot(fig, use_container_width=True)
                            st.success("✅ Wykres wyświetlony pomyślnie")
                        except Exception as plot_error:
                            st.error(f"❌ Błąd wyświetlania wykresu: {plot_error}")
                        finally:
                            plt.close(fig)
                    elif any(word in question.lower() for word in ['wykres', 'histogram', 'rozkład', 'porównaj', 'pokaż', 'wizualiz']):
                        st.info("💡 Zapytanie sugeruje wykres, ale AI go nie utworzyło. Spróbuj poprosić bezpośrednio o wykres.")
                    
                    # INTERPRETACJA AI
                    st.subheader("🧠 Interpretacja AI:")
                    with st.spinner("🔮 AI interpretuje wyniki..."):
                        interpretation = generate_interpretation(question, result, code, api_key)
                    st.markdown(interpretation)
                    
                    # Zapisz do historii
                    analysis_record = {
                        'question': question,
                        'code': code,
                        'result': result,
                        'interpretation': interpretation,
                        'timestamp': pd.Timestamp.now(),
                        'has_plot': fig is not None
                    }
                    st.session_state.analysis_history.append(analysis_record)
                    
                    # Zachęć do kolejnych pytań
                    st.markdown("---")
                    st.success("✅ Analiza zakończona! Możesz zadać kolejne pytanie powyżej.")
                    
                    # Sugestie kolejnych pytań na podstawie wyniku
                    if isinstance(result, pd.DataFrame) and len(result) > 1:
                        st.info("💡 Sugestia: Możesz zapytać o wykres dla tych wyników")
                    elif isinstance(result, (int, float)) and 'balans' in question.lower():
                        st.info("💡 Sugestia: Spróbuj 'Pokaż histogram balansu' lub 'Rozkład balansu klientów'")
                    elif 'top' in question.lower() or 'najwyższ' in question.lower():
                        st.info("💡 Sugestia: Możesz poprosić o wykres słupkowy dla tych wyników")
            
            else:
                st.error("❌ Nie udało się uzyskać odpowiedzi od AI")
                st.write("**Możliwe przyczyny:**")
                st.write("- Błąd klucza API")
                st.write("- Problem z połączeniem internetowym") 
                st.write("- Przeciążenie serwera DeepSeek")
        
        elif submit_button and not api_key:
            st.warning("⚠️ Wprowadź klucz API DeepSeek w lewym panelu")
        elif submit_button and not question.strip():
            st.warning("⚠️ Wprowadź pytanie do analizy")

with col2:
    st.header("📊 Informacje")
    
    if st.session_state.df is not None:
        df = st.session_state.df
        
        # Podstawowe metryki
        st.metric("📊 Wiersze", f"{len(df):,}")
        st.metric("📋 Kolumny", len(df.columns))
        
        # Informacje o pliku
        if st.session_state.file_info:
            st.subheader("📁 Format pliku")
            info = st.session_state.file_info
            st.write(f"**Separator:** `{info['separator']}`")
            st.write(f"**Kodowanie:** {info['encoding']}")
        
        # Typy danych
        st.subheader("🏷️ Typy kolumn")
        type_counts = df.dtypes.value_counts()
        for dtype, count in type_counts.items():
            st.write(f"**{str(dtype)}:** {count}")
        
        # Braki danych
        missing_data = df.isnull().sum()
        missing_cols = missing_data[missing_data > 0]
        
        if len(missing_cols) > 0:
            st.subheader("⚠️ Braki danych")
            for col, missing in missing_cols.items():
                pct = (missing / len(df)) * 100
                st.write(f"**{col}:** {missing:,} ({pct:.1f}%)")
        else:
            st.success("✅ Brak braków danych")
        
        # Kolumny numeryczne - podstawowe statystyki
        numeric_cols = df.select_dtypes(include=[np.number]).columns
        if len(numeric_cols) > 0:
            st.subheader("🔢 Statystyki numeryczne")
            for col in numeric_cols[:5]:
                try:
                    mean_val = df[col].mean()
                    min_val = df[col].min()
                    max_val = df[col].max()
                    st.write(f"**{col}:**")
                    st.write(f"  Średnia: {mean_val:.2f}")
                    st.write(f"  Zakres: {min_val:.2f} - {max_val:.2f}")
                except:
                    st.write(f"**{col}:** błąd obliczeń")
    else:
        st.info("👆 Wczytaj plik CSV aby zobaczyć statystyki")

# Footer
st.markdown("---")
st.markdown("🔧 **Funkcje:**")
col_f1, col_f2 = st.columns(2)

with col_f1:
    st.markdown("• **Automatyczne wykrywanie** formatu CSV")
    st.markdown("• **Obsługa separatorów:** `;` `,` `tab` `|`")
    st.markdown("• **Różne kodowania:** UTF-8, CP1250, Latin1")
    st.markdown("• **Inteligentne wyświetlanie** (omija błędy)")
    st.markdown("• **Szczegółowe logi** wykonania kodu")

with col_f2:
    st.markdown("• **Interpretacja AI** wyników analizy")
    st.markdown("• **Historia pytań** w sesji")
    st.markdown("• **Automatyczne wykresy** (histogram, bar, scatter)")
    st.markdown("• **Szybkie wykresy** jednym kliknięciem")
    st.markdown("• **Ciągłość analizy** - kolejne pytania")

st.info("💡 **Tip:** Pytaj o 'histogram', 'wykres', 'rozkład', 'porównanie' - AI automatycznie utworzy odpowiedni wykres!")

# Debug info
if st.session_state.analysis_history:
    plots_count = sum(1 for analysis in st.session_state.analysis_history if analysis.get('has_plot', False))
    st.caption(f"🎯 W tej sesji: {len(st.session_state.analysis_history)} analiz, {plots_count} wykresów")