import streamlit as st
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler, OneHotEncoder
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
import tensorflow as tf

# Data Initialization
location_df = pd.DataFrame({
    'location': ['Theni', 'Chennai', 'Thiruvallur', 'Coimbatore', 'Ariyalur'],
    'population_density': [21000, 11000, 8400, 7100, 6900],
    'gender_ratio': [0.92, 0.87, 0.95, 0.98, 0.89],
    'income_level': [45000, 52000, 48000, 38000, 35000],
    'farming_cycle': ['Kharif', 'Rabi', 'Mixed', 'Kharif', 'Mixed'],
    'seasonal_pattern': ['Monsoon', 'Winter', 'Year-round', 'Monsoon', 'Year-round']
})
scheme_df = pd.DataFrame({
    'scheme': ['Sukanya Samriddhi Yojana', 'Senior citizen saving schemes', 'Kisan Vikas Patra', 'Post office saving account', 'Monthly income scheme'],
    'ROI': [12.5, 8.2, 15.3, 10.1, 9.8],
    'target_gender': ['Both', 'Male', 'Both', 'Female', 'Both'],
    'target_age_group': ['Adult', 'Young', 'Adult', 'Senior', 'Young'],
    'tax_benefit': ['Yes', 'No', 'Yes', 'No', 'Yes'],
    'risk_level': ['Low', 'Medium', 'High', 'Low','Medium']
})
user_feedback_df = pd.DataFrame({
    'user_id': [1, 2, 3, 4, 5],
    'location': ['Theni', 'Chennai', 'Thiruvallur', 'Coimbatore', 'Ariyalur'],
    'scheme':  ['Sukanya Samriddhi Yojana', 'Senior citizen saving schemes', 'Kisan Vikas Patra', 'Post office saving account', 'Monthly income scheme'],
    'rating': [4.5, 3.8, 4.2, 3.9, 4.0]
})

# Data Preprocessing
scaler = MinMaxScaler()
location_df[['population_density', 'income_level']] = scaler.fit_transform(
    location_df[['population_density', 'income_level']]
)

encoder = OneHotEncoder(sparse_output=False)
location_encoder = OneHotEncoder(sparse_output=False)
location_cat_encoded = location_encoder.fit_transform(location_df[['farming_cycle', 'seasonal_pattern']])
location_cat_cols = location_encoder.get_feature_names_out(['farming_cycle', 'seasonal_pattern'])
location_encoded_df = pd.DataFrame(location_cat_encoded, columns=location_cat_cols)

scheme_encoder = OneHotEncoder(sparse_output=False)
scheme_cat_encoded = scheme_encoder.fit_transform(scheme_df[['target_gender', 'target_age_group', 'tax_benefit', 'risk_level']])
scheme_cat_cols = scheme_encoder.get_feature_names_out(['target_gender', 'target_age_group', 'tax_benefit', 'risk_level'])
scheme_encoded_df = pd.DataFrame(scheme_cat_encoded, columns=scheme_cat_cols)

location_features = pd.concat([
    location_df[['population_density', 'gender_ratio', 'income_level']],
    location_encoded_df
], axis=1)

scheme_features = pd.concat([
    scheme_df[['ROI']],
    scheme_encoded_df
], axis=1)

def create_autoencoder(input_dim):
    model = Sequential([
        Dense(32, activation='relu', input_shape=(input_dim,)),
        Dropout(0.2),
        Dense(16, activation='relu'),
        Dropout(0.2),
        Dense(8, activation='relu'),
        Dense(16, activation='relu'),
        Dense(32, activation='relu'),
        Dense(input_dim, activation='sigmoid')
    ])
    model.compile(optimizer='adam', loss='mse')
    return model

location_autoencoder = create_autoencoder(location_features.shape[1])
location_autoencoder.fit(location_features, location_features, epochs=10, batch_size=2, verbose=0)

scheme_autoencoder = create_autoencoder(scheme_features.shape[1])
scheme_autoencoder.fit(scheme_features, scheme_features, epochs=10, batch_size=2, verbose=0)

def create_recommendation_model(location_dim, scheme_dim):
    location_input = tf.keras.Input(shape=(location_dim,))
    scheme_input = tf.keras.Input(shape=(scheme_dim,))

    x1 = Dense(16, activation='relu')(location_input)
    x2 = Dense(16, activation='relu')(scheme_input)

    concat = tf.keras.layers.Concatenate()([x1, x2])
    x = Dense(32, activation='relu')(concat)
    x = Dropout(0.2)(x)
    x = Dense(16, activation='relu')(x)
    x = Dense(8, activation='relu')(x)
    output = Dense(1, activation='sigmoid')(x)

    model = tf.keras.Model(inputs=[location_input, scheme_input], outputs=output)
    model.compile(optimizer='adam', loss='mse')
    return model

X_loc = location_features.values
X_scheme = scheme_features.values
y = user_feedback_df['rating'].values / 5.0

recommendation_model = create_recommendation_model(X_loc.shape[1], X_scheme.shape[1])
recommendation_model.fit([X_loc, X_scheme], y, epochs=10, batch_size=2, verbose=0)

# Streamlit UI
st.title('Scheme Recommendation System')

# User input
location = st.selectbox('Select Location', location_df['location'].values)

if st.button('Get Recommendations'):
    if location not in location_df['location'].values:
        st.error('Invalid location')
    else:
        loc_features = location_features.loc[location_df['location'] == location].values
        loc_repeated = np.repeat(loc_features, len(scheme_features), axis=0)
        preds = recommendation_model.predict([loc_repeated, scheme_features.values], verbose=0)
        
        st.subheader(f'Recommendations for {location}')
        
        # Create a DataFrame for displaying results
        results = pd.DataFrame({
            'Scheme': scheme_df['scheme'],
            'Score': preds.flatten()
        }).sort_values(by='Score', ascending=False)
        
        st.dataframe(results)