import gradio as gr
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn import metrics
from reader import get_article


### ------------------------------ ###
###       data transformation      ###
### ------------------------------ ###
# options constants
options = [
  ['Very Poorly Aligned', 'Poorly Aligned', 'Neutrally Aligned', 'Well Aligned', 'Very Well Aligned'],
  ['Very Limited Experience', 'Limited Experience', 'Neutral Experience', 'Extensive Experience', 'Very Extensive Experience'],
  ['Extremely Unattractive', 'Moderately Unattractive', 'Neutrally Attractive', 'Moderately Attractive', 'Extremely Attractive'],
  ['Very Unfavorable', 'Moderately Unfavorable', 'Neutrally Favorable', 'Moderately Favorable', 'Very Favorable'],
  ['Very Poor Fit', 'Poor Fit', 'Neutral Fit', 'Moderately Good Fit', 'Excellent Fit']
]

# load dataset
uncleaned_data = pd.read_csv('data.csv')
data = pd.DataFrame()

# keep track of which columns are categorical and what 
# those columns' value mappings are
# structure: {colname1: {...}, colname2: {...} }
cat_value_dicts = {}
col = 0
final_colname = uncleaned_data.columns[4]

# for each column...
for (colname, colval) in uncleaned_data.iteritems():

  # structure: {0: "lilac", 1: "blue", ...}
  new_dict = {}
  transformed_col_vals = [] # new numeric datapoints

  # if not, for each item in that column...
  for (row, item) in enumerate(colval.values):

    # if item is not in this col's dict...
    if item not in new_dict:
      new_dict[item] = options[col].index(item)
    
    # then add numerical value to transformed dataframe
    transformed_col_vals.append(new_dict[item])
  
  # reverse dictionary only for final col (0, 1) => (vals)
  if colname == final_colname:
    new_dict = {value : key for (key, value) in new_dict.items()}

  cat_value_dicts[colname] = new_dict
  data[colname] = transformed_col_vals
  col += 1


### -------------------------------- ###
###           model training         ###
### -------------------------------- ###

# select features and predicton; automatically selects last column as prediction
num_features = 4
x = data.iloc[: , :num_features]
y = data.iloc[: , num_features:]

# split data into training and testing sets
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)

# instantiate the model (using default parameters)
model = LogisticRegression(max_iter=100)
model.fit(x_train, y_train.values.ravel())
y_pred = model.predict(x_test)


### -------------------------------- ###
###        article generation        ###
### -------------------------------- ###
# borrow file reading function from reader.py

def get_feat():
  feats = [abs(x) for x in model.coef_[0]]
  max_val = max(feats)
  idx = feats.index(max_val)
  return data.columns[idx]
  
acc = str(round(metrics.accuracy_score(y_test, y_pred) * 100, 2)) + '%'
feat = get_feat()
info = get_article(acc, feat)



### ------------------------------- ###
###        interface creation       ###
### ------------------------------- ###

def predictor(*args):
  features = []

  # transform categorical input
  for num, col in enumerate(args):
    features.append(cat_value_dicts[data.columns[num]][col])

  # predict single datapoint
  new_input = [features]
  result = model.predict(new_input)
  return cat_value_dicts[final_colname][result[0]]

# add data labels to replace those lost via star-args
inputls = []
labels = [
  "How Well Do They Align with RS21's 9 Core Values?",
  "How Experienced Are They in RS21's Markets?",
  "How Attractive is Their Valuation of RS21?",
  "How Favorable is Their Proposed Deal Structure for RS21?"
]

for num, colname in enumerate(labels):

  # access categories dict if data is categorical
  inputls.append(gr.inputs.Radio(choices=options[num], type="value", label=labels[num]))

  
# generate gradio interface
interface = gr.Interface(predictor, inputs=inputls, outputs="text", article=info['article'], css=info['css'], theme="grass", title=info['title'], allow_flagging='never', description=info['description'])

# show the interface 
interface.launch()