GSlides2

import gslides
from gslides import Presentation, Table, Chart, Series, Frame, Spreadsheet
import pandas as pd
import numpy as np
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
import os.path
from datetime import datetime, timedelta

SCOPES = ['https://www.googleapis.com/auth/presentations',
          'https://www.googleapis.com/auth/drive.file',
          'https://www.googleapis.com/auth/spreadsheets']

def get_credentials():
    """Get and refresh Google API credentials."""
    creds = None
    if os.path.exists('token.json'):
        creds = Credentials.from_authorized_user_file('token.json', SCOPES)
    
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        with open('token.json', 'w') as token:
            token.write(creds.to_json())
    
    return creds

def generate_time_series_data():
    """Generate sample time series data with trends and seasonality."""
    np.random.seed(42)
    dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
    
    # Base trend
    trend = np.linspace(100, 200, len(dates))
    
    # Seasonal component
    seasonal = 50 * np.sin(2 * np.pi * dates.dayofyear / 365)
    
    # Random noise
    noise = np.random.normal(0, 10, len(dates))
    
    data = {
        'Date': dates.strftime('%Y-%m-%d'),
        'Value': trend + seasonal + noise,
        'Trend': trend,
        'Seasonal': seasonal,
        'Noise': noise
    }
    return pd.DataFrame(data)

def generate_correlation_data():
    """Generate sample data with correlations and outliers."""
    np.random.seed(42)
    n = 100
    
    # Generate correlated data (X, Y, Z)
    cov_matrix = [[1, 0.8, 0.5], [0.8, 1, 0.6], [0.5, 0.6, 1]] # Added Z correlation
    x, y, z = np.random.multivariate_normal([0, 0, 0], cov_matrix, n).T # Generated Z
    
    # Add some outliers
    x = np.append(x, [3, -3, 3, -3])
    y = np.append(y, [3, -3, -3, 3])
    z = np.append(z, [0, 0, 0, 0]) # Added Z values for outliers
    
    data = {
        'X': x,
        'Y': y,
        'Z': z, # Added Z column
        'Group': ['A'] * (n//2) + ['B'] * (n//2) + ['Outlier'] * 4
    }
    return pd.DataFrame(data)

def generate_market_share_data():
    """Generate sample market share data."""
    categories = ['Category A', 'Category B', 'Category C', 'Category D']
    data = {
        'Category': categories,
        'Market Share': [35, 25, 20, 20],
        'Growth Rate': [5.2, 3.8, 2.5, 1.5]
    }
    return pd.DataFrame(data)

def generate_comparison_data():
    """Generate data for stacked and clustered column charts."""
    # Create data for stacked/clustered columns
    data = {
        'Category': ['A', 'B', 'C', 'D'] * 3,
        'Year': ['2021'] * 4 + ['2022'] * 4 + ['2023'] * 4,
        'Value': [10, 15, 12, 8, 14, 18, 16, 10, 18, 21, 19, 15]
    }
    stacked_df = pd.DataFrame(data)
    
    # Create data for performance comparison
    comparison_data = {
        'Category': ['A', 'B', 'C', 'D'],
        'Value': [25, 30, 28, 22],
        'Target': [28, 32, 25, 20]
    }
    comparison_df = pd.DataFrame(comparison_data)
    
    return stacked_df, comparison_df

def generate_advanced_data():
    """Generate sample data for advanced chart features."""
    # Generate data for area chart with stacking
    dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='M')
    area_data = pd.DataFrame({
        'Date': dates.strftime('%Y-%m-%d'),
        'Revenue': np.random.uniform(1000, 2000, len(dates)),
        'Costs': np.random.uniform(500, 1000, len(dates)),
        'Profit': np.random.uniform(200, 500, len(dates))
    })
    
    # Generate data for histogram
    hist_data = pd.DataFrame({
        'Values': np.concatenate([
            np.random.normal(100, 15, 1000),
            np.random.normal(150, 20, 500)
        ]),
        'Group': ['A'] * 1000 + ['B'] * 500
    })
    
    return area_data, hist_data

def generate_data():
    """Generate all required data for the presentation."""
    market_df = generate_market_share_data()
    stacked_df, comparison_df = generate_comparison_data()
    area_data, hist_data = generate_advanced_data()
    time_series_df = generate_time_series_data()
    correlation_df = generate_correlation_data()
    
    return market_df, stacked_df, area_data, hist_data, time_series_df, correlation_df

def main():
    """Main function to create the presentation and add slides."""
    creds = get_credentials()
    gslides.initialize_credentials(creds)
    
    # Create presentation and spreadsheet
    presentation = Presentation.create(
        'Comprehensive Features Demo'
    )
    
    spreadsheet = Spreadsheet.create(
        'Comprehensive Data',
        sheet_names=[
            'Market',
            'Comparison',
            'Stacked',
            'Area',
            'Histogram',
            'TimeSeries',
            'Correlation'
        ]
    )
    
    # Generate all data first
    market_df = generate_market_share_data()
    stacked_df, comparison_df = generate_comparison_data()
    area_data, hist_data = generate_advanced_data()
    time_series_df = generate_time_series_data()
    correlation_df = generate_correlation_data()
    
    # Create all frames
    market_frame = Frame.create(
        df=market_df,
        spreadsheet_id=spreadsheet.spreadsheet_id,
        sheet_id=spreadsheet.sheet_names['Market'],
        sheet_name='Market',
        overwrite_data=True
    )
    
    # Create frames for stacked and clustered charts
    stacked_frame = Frame.create(
        df=stacked_df.pivot_table(
            index='Category',
            columns='Year',
            values='Value',
            aggfunc='sum'
        ).reset_index(),
        spreadsheet_id=spreadsheet.spreadsheet_id,
        sheet_id=spreadsheet.sheet_names['Stacked'],
        sheet_name='Stacked',
        overwrite_data=True
    )
    
    # Create frame for comparison data
    comparison_frame = Frame.create(
        df=comparison_df,
        spreadsheet_id=spreadsheet.spreadsheet_id,
        sheet_id=spreadsheet.sheet_names['Comparison'],
        sheet_name='Comparison',
        overwrite_data=True
    )
    
    area_frame = Frame.create(
        df=area_data,
        spreadsheet_id=spreadsheet.spreadsheet_id,
        sheet_id=spreadsheet.sheet_names['Area'],
        sheet_name='Area',
        overwrite_data=True
    )
    
    hist_frame = Frame.create(
        df=hist_data,
        spreadsheet_id=spreadsheet.spreadsheet_id,
        sheet_id=spreadsheet.sheet_names['Histogram'],
        sheet_name='Histogram',
        overwrite_data=True
    )
    
    time_series_frame = Frame.create(
        df=time_series_df,
        spreadsheet_id=spreadsheet.spreadsheet_id,
        sheet_id=spreadsheet.sheet_names['TimeSeries'],
        sheet_name='TimeSeries',
        overwrite_data=True
    )
    
    correlation_frame = Frame.create(
        df=correlation_df,
        spreadsheet_id=spreadsheet.spreadsheet_id,
        sheet_id=spreadsheet.sheet_names['Correlation'],
        sheet_name='Correlation',
        overwrite_data=True
    )
    
    # 1. Time Series Analysis (Line Chart)
    time_series_chart = Chart(
        data=time_series_frame.data,
        x_axis_column='Date',
        series=[
            Series.line(series_columns=['Value']),
            Series.line(series_columns=['Trend']),
            Series.line(series_columns=['Seasonal'])
        ],
        title='Time Series Analysis',
        x_axis_label='Date',
        y_axis_label='Value',
        legend_position='RIGHT_LEGEND'
    )
    
    # 2. Correlation Analysis (Scatter Plot)
    scatter_chart = Chart(
        data=correlation_frame.data,
        x_axis_column='X',
        series=[Series.scatter(series_columns=['Y'])],
        title='Correlation Analysis',
        x_axis_label='X Value',
        y_axis_label='Y Value',
        legend_position='TOP_LEGEND'
    )
    
    # 3. Market Share (Column Chart)
    market_chart = Chart(
        data=market_frame.data,
        x_axis_column='Category',
        series=[Series.column(series_columns=['Market Share'])],
        title='Market Share Distribution',
        x_axis_label='Category',
        y_axis_label='Market Share (%)',
        legend_position='RIGHT_LEGEND'
    )
    
    # 4. Annotated Column Chart
    # Available data label placements:
    # - CENTER: Center of the bar
    # - LEFT: Left side of the bar
    # - RIGHT: Right side of the bar
    # - ABOVE: Above the bar
    # - BELOW: Below the bar
    # - INSIDE_END: Inside the bar at the end
    # - INSIDE_BASE: Inside the bar at the base
    # - OUTSIDE_END: Outside the bar at the end
    annotated_market_chart = Chart(
        data=market_frame.data,
        x_axis_column='Category',
        series=[
            Series.column(
                series_columns=['Market Share'],
                data_label_enabled=True,
                data_label_placement='OUTSIDE_END'
            )
        ],
        title='Annotated Market Share',
        x_axis_label='Category',
        y_axis_label='Market Share (%)',
        legend_position='RIGHT_LEGEND'
    )
    
    # 5. Stacked Column Chart
    stacked_chart = Chart(
        data=stacked_frame.data,
        x_axis_column='Category',
        series=[
            Series.column(series_columns=['2021']),
            Series.column(series_columns=['2022']),
            Series.column(series_columns=['2023'])
        ],
        stacking='STACKED',
        title='Stacked Column Chart',
        x_axis_label='Category',
        y_axis_label='Value',
        legend_position='RIGHT_LEGEND'
    )
    
    # 6. Clustered Column Chart
    clustered_chart = Chart(
        data=stacked_frame.data,
        x_axis_column='Category',
        series=[
            Series.column(series_columns=['2021']),
            Series.column(series_columns=['2022']),
            Series.column(series_columns=['2023'])
        ],
        title='Clustered Column Chart',
        x_axis_label='Category',
        y_axis_label='Value',
        legend_position='RIGHT_LEGEND'
    )
    
    # 7. Financial Performance (Area Chart)
    area_chart = Chart(
        data=area_frame.data,
        x_axis_column='Date',
        series=[
            Series.area(series_columns=['Revenue']),
            Series.area(series_columns=['Costs']),
            Series.area(series_columns=['Profit'])
        ],
        title='Financial Performance Over Time',
        x_axis_label='Date',
        y_axis_label='Amount ($)',
        legend_position='RIGHT_LEGEND'
    )
    
    # 8. Distribution Analysis (Histogram)
    histogram = Chart(
        data=hist_frame.data,
        x_axis_column='Values',
        series=[Series.histogram(series_columns=['Values'])],
        title='Distribution Analysis',
        x_axis_label='Value',
        y_axis_label='Frequency',
        legend_position='BOTTOM_LEGEND'
    )
    
    # 9. Mixed Chart Types
    mixed_chart = Chart(
        data=comparison_frame.data,
        x_axis_column='Category',
        series=[
            Series.column(series_columns=['Value']),
            Series.line(series_columns=['Target'])
        ],
        title='Performance vs Target',
        x_axis_label='Category',
        y_axis_label='Value',
        legend_position='TOP_LEGEND'
    )
    
    # 10. Pivoted Table
    table = Table(data=comparison_df)
    
    # 11. Styled Time Series Chart (with different colors and font)
    styled_time_series = Chart(
        data=time_series_frame.data,
        x_axis_column='Date',
        series=[
            Series.line(series_columns=['Value']),  # Will use default color
            Series.line(series_columns=['Trend']),  # Will use default color
            Series.line(series_columns=['Seasonal'])  # Will use default color
        ],
        title='Styled Time Series Analysis',
        x_axis_label='Date',
        y_axis_label='Value',
        legend_position='RIGHT_LEGEND'
    )
    
    # 12. Scatter Plot with Different Columns and Colors
    colored_scatter = Chart(
        data=correlation_frame.data,
        x_axis_column='X',
        series=[
            Series.scatter(series_columns=['Y'], color='#FF0000', point_shape='CIRCLE'),  # Plot Y in Red circles
            Series.scatter(series_columns=['Z'], color='#0000FF', point_shape='SQUARE')   # Plot Z in Blue squares
        ],
        title='Multi-Column Colored Scatter Plot (Y vs X, Z vs X)',
        x_axis_label='X Value',
        y_axis_label='Y / Z Value',
        legend_position='TOP_LEGEND'
    )
    
    # Add all chart slides
    presentation.add_slide(
        objects=[time_series_chart],
        layout=(1,1),
        title="Time Series Analysis",
        notes="Decomposition of time series into trend, seasonal, and noise components"
    )
    
    presentation.add_slide(
        objects=[scatter_chart],
        layout=(1,1),
        title="Correlation Analysis",
        notes="Scatter plot showing correlation between X and Y variables"
    )
    
    presentation.add_slide(
        objects=[market_chart],
        layout=(1,1),
        title="Market Share",
        notes="Basic column chart showing market share distribution"
    )
    
    presentation.add_slide(
        objects=[annotated_market_chart],
        layout=(1,1),
        title="Annotated Market Share",
        notes="Column chart with data labels outside the bars"
    )
    
    presentation.add_slide(
        objects=[stacked_chart, clustered_chart],
        layout=(1,2),
        title="Stacked vs Clustered Columns",
        notes="Comparison of stacking vs clustering"
    )
    
    presentation.add_slide(
        objects=[area_chart],
        layout=(1,1),
        title="Financial Performance",
        notes="Area chart showing revenue, costs, and profit"
    )
    
    presentation.add_slide(
        objects=[histogram],
        layout=(1,1),
        title="Distribution Analysis",
        notes="Histogram showing value distribution"
    )
    
    presentation.add_slide(
        objects=[mixed_chart],
        layout=(1,1),
        title="Performance vs Target",
        notes="Mixed chart showing actual vs target"
    )
    
    presentation.add_slide(
        objects=[table],
        layout=(1,1),
        title="Data Table",
        notes="Raw data in tabular format"
    )
    
    # Add styled time series slide
    presentation.add_slide(
        objects=[styled_time_series],
        layout=(1,1),
        title="Styled Time Series",
        notes="Time series with custom colors"
    )
    
    # Add colored scatter plot slide
    presentation.add_slide(
        objects=[colored_scatter],
        layout=(1,1),
        title='Multi-Column Colored Scatter Plot',
        notes='Scatter plot showing Y vs X (Red Circles) and Z vs X (Blue Squares)'
    )
    
    print(f"Presentation created with ID: {presentation.presentation_id}")
    print(f"Spreadsheet created with ID: {spreadsheet.spreadsheet_id}")

if __name__ == "__main__":
    main()