import pandas as pd
import numpy as np
import pylab as pl
import plotly.express as px
import plotly.graph_objects as go
import gradio as gr
import matplotlib.pyplot as plt
from matplotlib.ticker import FormatStrFormatter
import seaborn as sns
from sklearn import linear_model

def update_table(coordx,coordy,coordz,plotting_df):
  plotting_df = plotting_df[plotting_df['type'] != "User"]
  xx=plotting_df.columns[3]
  yy=plotting_df.columns[4]
  zz=plotting_df.columns[5]
  plotting_df=plotting_df.drop([xx,yy,zz], axis=1)
  to_merge=pd.concat([df['group'],df[coordx],df[coordy],df[coordz]],axis=1) #assumes already rounded df. will needto be rounded here if not
  plotting_df=plotting_df.merge(to_merge,how='left',on=['group'])
  return gr.update(value=plotting_df)

def refresh(coordx,coordy,coordz):
  for coord in [coordx,coordy,coordz]:
    for jj in range(0,len(df[coord])):
      try:
        float(df[coord][jj])
        df[coord][jj]=round(df[coord][jj],3)
      except:
        df[coord][jj]= ""
        df[coord][jj]= " "
        df[coord][jj]= "--"
  plotting_df=pd.concat([df['class'],df['type'],df['group'],df[coordx],df[coordy],df[coordz]],axis=1)
  return gr.update(value=plotting_df), gr.update(value=True),gr.update(value=True),gr.update(value=True)


def plot(plotting_df,x_vals, y_vals, z_vals):
#get error row IDs:
  x_errors=df.columns[(df.columns.get_loc(f'{x_vals}'))+1]
  y_errors=df.columns[(df.columns.get_loc(f'{y_vals}'))+1]
  z_errors=df.columns[(df.columns.get_loc(f'{z_vals}'))+1]

  to_merge=pd.concat([df['group'],df[x_errors],df[y_errors],df[z_errors]], axis=1) #if original df values must be used for plotting - would also add x,y,z_vals here, and drop them from temp_df - still merge on subgroup
  temp_df=plotting_df.merge(to_merge,how='left',on=['group'])
  #omits '-- from temporary plotting dfs
  temp_xyz = pd.DataFrame(columns=temp_df.columns)
  temp_xy = pd.DataFrame(columns=temp_df.columns)
  temp_yz = pd.DataFrame(columns=temp_df.columns)
  temp_zx = pd.DataFrame(columns=temp_df.columns)
  for index, row in temp_df.iterrows():
    x = row[x_vals]
    y = row[y_vals]
    z = row[z_vals]
    if x != '--' and y != '--' and z != '--':
        temp_xyz = pd.concat([temp_xyz, row.to_frame().T])
    if x != '--' and y != '--':
        temp_xy = pd.concat([temp_xy, row.to_frame().T])
    if y != '--' and z != '--':
        temp_yz = pd.concat([temp_yz, row.to_frame().T])
    if z != '--' and x != '--':
        temp_zx = pd.concat([temp_zx, row.to_frame().T])
  temp_xyz.reset_index(drop=True, inplace=True)
  temp_xy.reset_index(drop=True, inplace=True)
  temp_yz.reset_index(drop=True, inplace=True)
  temp_zx.reset_index(drop=True, inplace=True)
  #get min and max for kde ranges:
  cols=[x_vals,y_vals,z_vals]
  temp_xyz.loc[:, cols] = temp_xyz.loc[:, cols].astype(float)
  min_x = temp_xyz[x_vals].min()
  max_x = temp_xyz[x_vals].max()
  min_y = temp_xyz[y_vals].min()
  max_y = temp_xyz[y_vals].max()
  min_z = temp_xyz[z_vals].min()
  max_z = temp_xyz[z_vals].max()
  #3D plot:
  markers={'Chon': 'circle', 'Iron': 'x', 'Acho': 'square', 'Plan': 'square', 'CAIs': 'diamond', 'User':'circle'}#, 'CI':'circle'
  fig0= px.scatter_3d(data_frame=temp_xyz,x=x_vals,y=y_vals,  z=z_vals , color='class', color_discrete_map={'CC':'blue','CI':'#a4dded','NC':'red','Other':'green','NA':'#FFEF00'},symbol='type', symbol_map=markers, hover_name='group',
                    hover_data={'class': False, 'type':False})
  fig0.update_layout(template="none",  showlegend=True, legend=dict(y=0.0, itemsizing="constant",title=""), modebar=dict(orientation='h'))#margin=dict(l=50, r=50, b=50, t=50),
  fig0.update_traces(marker=dict(size=5, line=dict(color='white', width=4)))
  fig0.update_traces(selector=dict(marker_color='#FFEF00'), marker=dict(line_color='black'))
  #x vs y:
  fig01=px.scatter(temp_xy,x=x_vals,y=y_vals, color='class',color_discrete_map={'CC':'blue','CI':'#a4dded','NC':'red','Other':'green','NA':'#FFEF00'},symbol='type', symbol_map=markers, hover_name='group',
                    hover_data={'class': False, 'type':False}, error_x=x_errors, error_y=y_errors)
  fig01.update_layout(template="simple_white", showlegend=True, legend=dict(title='',y=1.0, xanchor="right",x=0.2, bgcolor='rgba(0,0,0,0)'), modebar=dict(orientation='h'))
  fig01.update_traces(marker=dict(size=9, line=dict(color='white', width=1)), error_x_width=0,error_y_width=0)
  fig01.update_traces(selector=dict(marker_color='#FFEF00'), marker=dict(line_color='black'))
  fig01.update_xaxes(mirror=True)
  fig01.update_yaxes(mirror=True)
  #hist1:
  palette = {'CC': '#0000FF', 'NC': '#FF0000', 'Other': '#00FF00'}
  df_yclean = temp_df[temp_df[y_vals] != "--"]
  #df_yclean[y_vals]=df_yclean[y_vals].astype(float)
  df_ydich=df_yclean[df_yclean['class'].isin(['CC','NC'])]
  hist1=plt.figure(figsize=(1.5,4.47),tight_layout=dict(pad=0.1))
  sns.kdeplot(data=df_ydich, y=y_vals, hue='class', palette=palette, fill=True)
  plt.ylim(min_y-abs(min_y*0.23),max_y+abs(max_y*0.19)) #may need to be a factor of average y val, not min and max...
  plt.yticks([])
  plt.ylabel('')
  plt.gca().xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
  legend = plt.gca().get_legend()
  legend.set_title('')
  #y vs z:
  fig02=px.scatter(temp_yz,x=y_vals,y=z_vals, color='class',color_discrete_map={'CC':'blue','CI':'#a4dded','NC':'red','Other':'green','NA':'#FFEF00'},symbol='type',symbol_map=markers, hover_name='group',
                    hover_data={'class': False, 'type':False},
                    error_x=y_errors, error_y=z_errors)
  fig02.update_layout(template="simple_white", showlegend=True, legend=dict(title='',y=1.0, xanchor="right",x=0.2, bgcolor='rgba(0,0,0,0)'), modebar=dict(orientation='h'))
  fig02.update_traces(marker=dict(size=9, line=dict(color='white', width=1)), error_x_width=0,error_y_width=0)
  fig02.update_traces(selector=dict(marker_color='#FFEF00'), marker=dict(line_color='black'))
  fig02.update_xaxes(mirror=True)
  fig02.update_yaxes(mirror=True)
  #hist2:
  df_zclean = temp_df[temp_df[z_vals] != "--"]
  #df_zclean[z_vals]=df_zclean[z_vals].astype(float)
  df_zdich=df_zclean[df_zclean['class'].isin(['CC','NC'])]
  hist2=plt.figure(figsize=(1.5,4.47),tight_layout=dict(pad=0.1))
  sns.kdeplot(data=df_zdich, y=z_vals, hue='class', palette=palette, fill=True)
  plt.ylim(min_z-abs(min_z*0.23),max_z+abs(max_z*0.19))
  plt.yticks([])
  plt.ylabel('')
  plt.gca().xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
  legend = plt.gca().get_legend()
  legend.set_title('')
  #z vs x:
  fig03=px.scatter(temp_zx,x=z_vals,y=x_vals, color='class',color_discrete_map={'CC':'blue','CI':'#a4dded','NC':'red','Other':'green','NA':'#FFEF00'},symbol='type', symbol_map=markers, hover_name='group',
                    hover_data={'class': False, 'type':False},
                    error_x=z_errors,error_y=x_errors)
  fig03.update_layout(template="simple_white", showlegend=True, legend=dict(title='',y=1.0, xanchor="right",x=0.2, bgcolor='rgba(0,0,0,0)'), modebar=dict(orientation='h'))
  fig03.update_traces(marker=dict(size=9, line=dict(color='white', width=1)), error_x_width=0,error_y_width=0)
  fig03.update_traces(selector=dict(marker_color='#FFEF00'), marker=dict(line_color='black'))
  fig03.update_xaxes(mirror=True)
  fig03.update_yaxes(mirror=True)
  #hist3:
  df_xclean = temp_df[temp_df[x_vals] != "--"]
  #df_xclean[x_vals]=df_xclean[x_vals].astype(float)
  df_xdich=df_xclean[df_xclean['class'].isin(['CC','NC'])]
  hist3=plt.figure(figsize=(1.5,4.47),tight_layout=dict(pad=0.1))
  sns.kdeplot(data=df_xdich, y=x_vals, hue='class',palette=palette, fill=True)
  plt.ylim(min_x-abs(min_x*0.23),max_x+abs(max_x*0.19))
  plt.yticks([])
  plt.ylabel('')
  plt.gca().xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
  legend = plt.gca().get_legend()
  legend.set_title('')
  return gr.update(value=fig0, visible=True),gr.update(value=fig01, visible=True),gr.update(value=fig02, visible=True),gr.update(value=fig03, visible=True), gr.update(value=hist1, visible=True),gr.update(value=hist2, visible=True),gr.update(value=hist3, visible=True), fig01,fig02,fig03

def cc_checkbox_check(plotting_df,CC_check, x_vals,y_vals,z_vals):
  temp_columns=df[['class','type','group',x_vals,y_vals,z_vals]]
  temp_df=pd.concat([temp_columns],axis=1)
  plotting_df=plotting_df[plotting_df['class']!='CC']
  if CC_check==False:
    return plotting_df
  else:
    plotting_df=pd.concat([plotting_df,temp_df[temp_df['class']=='CC']], axis=0)
    return plotting_df
def nc_checkbox_check(plotting_df,NC_check, x_vals,y_vals,z_vals):
  temp_columns=df[['class','type','group',x_vals,y_vals,z_vals]]
  temp_df=pd.concat([temp_columns],axis=1)
  plotting_df=plotting_df[plotting_df['class']!='NC']
  if NC_check==False:
    return plotting_df
  else:
    plotting_df=pd.concat([plotting_df,temp_df[temp_df['class']=='NC']], axis=0)
    return plotting_df
def other_checkbox_check(plotting_df,Other_check, x_vals,y_vals,z_vals):
  temp_columns=df[['class','type','group',x_vals,y_vals,z_vals]]
  temp_df=pd.concat([temp_columns],axis=1)
  plotting_df=plotting_df[plotting_df['class']!='Other']
  if Other_check==False:
    return plotting_df
  else:
    plotting_df=pd.concat([plotting_df,temp_df[temp_df['class']=='Other']], axis=0)
    return plotting_df

def updateAdd_xchange(x,add_data):
  headers=add_data.columns
  if x in headers:
    return gr.update(value=add_data)
  else:
    new_col = pd.DataFrame(columns=[x], index=add_data.index)
    add_data=pd.concat([add_data,new_col],axis=1)
    return gr.update(value=add_data)

def updateAdd_ychange(y,add_data):
  headers=add_data.columns
  if y in headers:
    return gr.update(value=add_data)
  else:
    new_col = pd.DataFrame(columns=[y], index=add_data.index)
    add_data=pd.concat([add_data,new_col],axis=1)
    return gr.update(value=add_data)

def updateAdd_zchange(z,add_data):
  headers=add_data.columns
  if z in headers:
    return gr.update(value=add_data)
  else:
    new_col = pd.DataFrame(columns=[z], index=add_data.index)
    add_data=pd.concat([add_data,new_col],axis=1)
    return gr.update(value=add_data)

def resetAdd(x_vals,y_vals,z_vals):
  new=pd.DataFrame(columns=['ID',x_vals,y_vals,z_vals])
  return gr.update(value=new)

def appendFn(add_data,plotting_df):
  adding=pd.DataFrame(columns=['class','type'], index=add_data.index)
  adding['class']='NA'
  adding['type']='User'
  x=plotting_df.columns[3]
  y=plotting_df.columns[4]
  z=plotting_df.columns[5]
  add_data = add_data.rename(columns={'ID': 'group'})
  adding=pd.concat([adding,add_data['group'],add_data[x],add_data[y],add_data[z]], axis=1)
  for row in [adding.columns[3],adding.columns[4],adding.columns[5]]:
    for jj in range(0,adding.shape[0]):
      if adding[row][jj]=='':
        adding[row][jj]='--'
  plotting_df=pd.concat([plotting_df,adding],axis=0)
  return gr.update(value=plotting_df)

def twoD_regs(CC_reg,NC_reg,x_vals,y_vals,z_vals,plotting_df):
  _,_,_,_,_,_,_,fig01,fig02,fig03=plot(plotting_df,x_vals,y_vals,z_vals)
  fig11=fig01
  fig22=fig02
  fig33=fig03
  model=linear_model.TheilSenRegressor(random_state=42)
  reg_df = df[['class',x_vals,y_vals,z_vals]].copy() #pulls from parent df - currently rounded values
  CCreg_df = reg_df[reg_df['class'] == 'CC']
  NCreg_df = reg_df[reg_df['class'] == 'NC']
#temporary dfs
  cc_temp_xy=CCreg_df[['class',x_vals,y_vals]].copy()
  cc_temp_xy=cc_temp_xy[~(cc_temp_xy == '--').any(axis=1)]

  cc_temp_yz=CCreg_df[['class',y_vals,z_vals]].copy()
  cc_temp_yz=cc_temp_yz[~(cc_temp_yz == '--').any(axis=1)]

  cc_temp_zx=CCreg_df[['class',z_vals,x_vals]].copy()
  cc_temp_zx=cc_temp_zx[~(cc_temp_zx == '--').any(axis=1)]

  nc_temp_xy=NCreg_df[['class',x_vals,y_vals]].copy()
  nc_temp_xy=nc_temp_xy[~(nc_temp_xy == '--').any(axis=1)]

  nc_temp_yz=NCreg_df[['class',y_vals,z_vals]].copy()
  nc_temp_yz=nc_temp_yz[~(nc_temp_yz == '--').any(axis=1)]

  nc_temp_zx=NCreg_df[['class',z_vals,x_vals]].copy()
  nc_temp_zx=nc_temp_zx[~(nc_temp_zx == '--').any(axis=1)]
#min-max ranges: #equivalent to x_range in robust regression.pynb
  cc_xx=cc_temp_xy[x_vals].to_numpy().reshape(-1,1)
  cc_xy1 = np.array([min(cc_xx),max(cc_xx)])

  cc_yy=cc_temp_yz[y_vals].to_numpy().reshape(-1,1)
  cc_yz1 = np.array([min(cc_yy),max(cc_yy)])

  cc_zz=cc_temp_zx[z_vals].to_numpy().reshape(-1,1)
  cc_zx1 = np.array([min(cc_zz),max(cc_zz)])
#NC
  nc_xx=nc_temp_xy[x_vals].to_numpy().reshape(-1,1)
  nc_xy1 = np.array([min(nc_xx),max(nc_xx)])

  nc_yy=nc_temp_yz[y_vals].to_numpy().reshape(-1,1)
  nc_yz1 = np.array([min(nc_yy),max(nc_yy)])

  nc_zz=nc_temp_zx[z_vals].to_numpy().reshape(-1,1)
  nc_zx1 = np.array([min(nc_zz),max(nc_zz)])
#########model fitting, creation of regression traces
  CC_m1,CC_m2,CC_m3,CC_b1,CC_b2,CC_b3,NC_m1,NC_m2,NC_m3,NC_b1,NC_b2,NC_b3 = 1,1,1,1,1,1,1,1,1,1,1,1

  model.fit(cc_xx,cc_temp_xy[y_vals].to_numpy()) #if sizes are an issue, change this to just y_vals .to numpy
  cc_r1=model.score(cc_xx,cc_temp_xy[y_vals].to_numpy()).round(5)
  cc_xy2=model.predict(cc_xy1)
  CC_m1=model.coef_
  CC_b1=model.intercept_
  trace1 = go.Scatter(x=np.ravel(cc_xy1),y=np.ravel(cc_xy2),mode='lines',line=dict(color='blue'),showlegend=False,hoverinfo='text',hovertext=f'CC Regression<br>Correlation Coef.:{cc_r1}')
  model.fit(nc_xx,nc_temp_xy[y_vals].to_numpy())
  nc_r1=model.score(nc_xx,nc_temp_xy[y_vals].to_numpy()).round(5)
  nc_xy2=model.predict(nc_xy1)
  NC_m1=model.coef_
  NC_b1=model.intercept_
  trace1a = go.Scatter(x=np.ravel(nc_xy1),y=np.ravel(nc_xy2),mode='lines',line=dict(color='red'),showlegend=False,hoverinfo='text',hovertext=f'NC Regression<br>Correlation Coef.:{nc_r1}')

  model.fit(cc_yy,cc_temp_yz[z_vals].to_numpy())
  cc_r2=model.score(cc_yy,cc_temp_yz[z_vals].to_numpy()).round(5)
  cc_yz2=model.predict(cc_yz1)
  CC_m2=model.coef_
  CC_b2=model.intercept_
  trace2 = go.Scatter(x=np.ravel(cc_yz1),y=np.ravel(cc_yz2),mode='lines',line=dict(color='blue'),showlegend=False,hoverinfo='text',hovertext=f'CC Regression<br>Correlation Coef.:{cc_r2}')
  model.fit(nc_yy,nc_temp_yz[z_vals].to_numpy())
  nc_r2=model.score(nc_yy,nc_temp_yz[z_vals].to_numpy()).round(5)
  nc_yz2=model.predict(nc_yz1)
  NC_m2=model.coef_
  NC_b2=model.intercept_
  trace2a = go.Scatter(x=np.ravel(nc_yz1),y=np.ravel(nc_yz2),mode='lines',line=dict(color='red'),showlegend=False,hoverinfo='text',hovertext=f'NC Regression<br>Correlation Coef.:{nc_r2}')

  model.fit(cc_zz,cc_temp_zx[x_vals].to_numpy())
  cc_r3=model.score(cc_zz,cc_temp_zx[x_vals].to_numpy()).round(5)
  cc_zx2=model.predict(cc_zx1)
  CC_m3=model.coef_
  CC_b3=model.intercept_
  trace3 = go.Scatter(x=np.ravel(cc_zx1),y=np.ravel(cc_zx2),mode='lines',line=dict(color='blue'),showlegend=False,hoverinfo='text',hovertext=f'CC Regression<br>Correlation Coef.:{cc_r3}')
  model.fit(nc_zz,nc_temp_zx[x_vals].to_numpy())
  nc_r3=model.score(nc_zz,nc_temp_zx[x_vals].to_numpy()).round(5)
  nc_zx2=model.predict(nc_zx1)
  NC_m3=model.coef_
  NC_b3=model.intercept_
  trace3a = go.Scatter(x=np.ravel(nc_zx1),y=np.ravel(nc_zx2),mode='lines',line=dict(color='red'),showlegend=False,hoverinfo='text',hovertext=f'NC Regression<br>Correlation Coef.:{nc_r3}')
##conditional statement which selectively appends regs based on boolean of regression buttons
  vp=0 #visibility param
  if CC_reg==True and NC_reg==False: ##just CC regs
    vp=1
    fig11 = fig01.to_dict()
    fig11['data'].append(trace1)
    #fig11['data'].append(trace1a)
    fig11 = go.Figure(fig11)

    fig22 = fig02.to_dict()
    fig22['data'].append(trace2)
    #fig22['data'].append(trace2a)
    fig22 = go.Figure(fig22)

    fig33 = fig03.to_dict()
    fig33['data'].append(trace3)
    #fig33['data'].append(trace3a)
    fig33= go.Figure(fig33)
  elif CC_reg==False and NC_reg==True: ##just NC regs
    vp=1
    fig11 = fig01.to_dict()
    #fig11['data'].append(trace1)
    fig11['data'].append(trace1a)
    fig11 = go.Figure(fig11)

    fig22 = fig02.to_dict()
    #fig22['data'].append(trace2)
    fig22['data'].append(trace2a)
    fig22 = go.Figure(fig22)

    fig33 = fig03.to_dict()
    #fig33['data'].append(trace3)
    fig33['data'].append(trace3a)
    fig33= go.Figure(fig33)
  elif CC_reg==True and NC_reg==True: ##both
    vp=1
    fig11 = fig01.to_dict()
    fig11['data'].append(trace1)
    fig11['data'].append(trace1a)
    fig11 = go.Figure(fig11)

    fig22 = fig02.to_dict()
    fig22['data'].append(trace2)
    fig22['data'].append(trace2a)
    fig22 = go.Figure(fig22)

    fig33 = fig03.to_dict()
    fig33['data'].append(trace3)
    fig33['data'].append(trace3a)
    fig33= go.Figure(fig33)
  #else:
  ###############begin 3D regression
  df4=df.copy()
  df4.replace('--', np.nan,inplace=True)
  temp_x=df4[x_vals].dropna()
  temp_y=df4[y_vals].dropna()
  temp_z=df4[z_vals].dropna()
  ###CC 3D reg
  if (cc_r1 and cc_r2)>cc_r3: ## y vs x ++++ z vs y :: y_vals is common var, m1/b1 flips, m2/b2 remains
    val=1
    model.fit(cc_temp_xy[y_vals].to_numpy().reshape(-1,1),cc_temp_xy[x_vals].to_numpy())
    #CC_m1=model.coef_
    #CC_b1=model.intercept_
    passing_min=min(temp_y)
    passing_max=max(temp_y)
    CC_reg_min,CC_reg_max=threeD_regs_calcs(model.coef_,model.intercept_,CC_m2,CC_b2,passing_min,passing_max,val)
  elif (cc_r1 and cc_r3)>cc_r2: ## y vs x ++++ x vs z :: x_vals is common var, m3/b3 flips ; m1/b1 remains
    val=2
    model.fit(cc_temp_zx[x_vals].to_numpy().reshape(-1,1),cc_temp_zx[z_vals].to_numpy())
    #CC_m3=model.coef_
    #CC_b3=model.intercept_
    passing_min=min(temp_x)
    passing_max=max(temp_x)
    CC_reg_min,CC_reg_max=threeD_regs_calcs(CC_m1,CC_b1,model.coef_,model.intercept_,passing_min,passing_max,val)
  elif (cc_r2 and cc_r3)>cc_r1: ## z vs y ++++ x vs z :: z_vals is common var, m2/b2 flips, m3/b3 remains
    val=3
    model.fit(cc_temp_yz[z_vals].to_numpy().reshape(-1,1),cc_temp_yz[y_vals].to_numpy())
    #CC_m2=model.coef_
    #CC_b2=model.intercept_
    passing_min=min(temp_z)
    passing_max=max(temp_z)
    CC_reg_min,CC_reg_max=threeD_regs_calcs(model.coef_,model.intercept_,CC_m3,CC_b3,passing_min,passing_max,val)

  ###NC 3D reg
  if (nc_r1 and nc_r2)>nc_r3: ## y vs x ++++ z vs y :: y_vals is common var, m1/b1 flips, m2/b2 remains
    val=1
    model.fit(nc_temp_xy[y_vals].to_numpy().reshape(-1,1),nc_temp_xy[x_vals].to_numpy())
    #NC_m1=model.coef_
    #NC_b1=model.intercept_
    passing_min=min(temp_y)
    passing_max=max(temp_y)
    NC_reg_min,NC_reg_max=threeD_regs_calcs(model.coef_,model.intercept_,NC_m2,NC_b2,passing_min,passing_max,val)
  elif (nc_r1 and nc_r3)>nc_r2: ## y vs x ++++ x vs z :: x_vals is common var, m3/b3 flips ; m1/b1 remains
    val=2
    model.fit(nc_temp_zx[x_vals].to_numpy().reshape(-1,1),nc_temp_zx[z_vals].to_numpy())
    #NC_m3=model.coef_
    #NC_b3=model.intercept_
    passing_min=min(temp_x)
    passing_max=max(temp_x)
    NC_reg_min,NC_reg_max=threeD_regs_calcs(NC_m1,NC_b1,model.coef_,model.intercept_,passing_min,passing_max,val)
  elif (nc_r2 and nc_r3)>nc_r1: ## z vs y ++++ x vs z :: z_vals is common var, m2/b2 flips, m3/b3 remains
    val=3
    model.fit(nc_temp_yz[z_vals].to_numpy().reshape(-1,1),nc_temp_yz[y_vals].to_numpy())
    #NC_m2=model.coef_
    #NC_b2=model.intercept_
    passing_min=min(temp_z)
    passing_max=max(temp_z)
    NC_reg_min,NC_reg_max=threeD_regs_calcs(model.coef_,model.intercept_,NC_m3,NC_b3,passing_min,passing_max,val)
  #creates df with 3Dregression data
  id_df=pd.DataFrame(['CC_low','CC_high','NC_low','NC_high'], columns=['ID'])
  temp_reg_df=pd.DataFrame([CC_reg_min,CC_reg_max,NC_reg_min,NC_reg_max], columns=[x_vals, y_vals, z_vals])
  passing_df = pd.concat([id_df, temp_reg_df], axis=1)
  if vp==0:
    return gr.update(value=fig11),gr.update(value=fig22),gr.update(value=fig33),gr.update(value=passing_df,visible=False),gr.update(value="Update 3D Regression", visible=False)
  else:
    return gr.update(value=fig11),gr.update(value=fig22),gr.update(value=fig33),gr.update(value=passing_df,visible=True),gr.update(value="Update 3D Regression", visible=True)

def threeD_regs_calcs(m1,b1,m2,b2,passing_min,passing_max,val):
  if val==1:
    xmin=float((m1*passing_min)+b1)
    xmax=float((m1*passing_max)+b1)
    zmin=float((m2*passing_min)+b2)
    zmax=float((m2*passing_max)+b2)
    min_coord=np.round([xmin,passing_min,zmin],4)
    max_coord=np.round([xmax,passing_max,zmax],4)
    return min_coord,max_coord

  elif val == 2:
    ymin=float((m1*passing_min)+b1)
    ymax=float((m1*passing_max)+b1)
    zmin=float((m2*passing_min)+b2)
    zmax=float((m2*passing_max)+b2)
    min_coord=np.round([passing_min,ymin,zmin],4)
    max_coord=np.round([passing_max,ymax,zmax],4)
    return min_coord,max_coord

  elif val == 3:
    ymin=float((m1*passing_min)+b1)
    ymax=float((m1*passing_max)+b1)
    xmin=float((m2*passing_min)+b2)
    xmax=float((m2*passing_max)+b2)
    min_coord=np.round([xmin,ymin,passing_min],4)
    max_coord=np.round([xmax,ymax,passing_max],4)
    return min_coord,max_coord

def regs_False():
  return gr.update(value=False), gr.update (value=False),gr.update(visible=False) , gr.update(value="Update 3D Regression", visible=False)

def plot_3D_reg(plotting_df,reg_df,x_vals, y_vals, z_vals,CC_reg,NC_reg):
#omits '-- from temporary plotting dfs
  temp_xyz = pd.DataFrame(columns=plotting_df.columns)
  for index, row in plotting_df.iterrows():
    x = row[x_vals]
    y = row[y_vals]
    z = row[z_vals]
    if x != '--' and y != '--' and z != '--':
        temp_xyz = pd.concat([temp_xyz, row.to_frame().T])
  temp_xyz.reset_index(drop=True, inplace=True)
#3D plot:
  markers={'Chon': 'circle', 'Iron': 'x', 'Acho': 'square', 'Plan': 'square', 'CAIs': 'diamond', 'User':'circle'}#, 'CI':'circle'
  fig0= px.scatter_3d(data_frame=temp_xyz,x=x_vals,y=y_vals,  z=z_vals , color='class', color_discrete_map={'CC':'blue','CI':'#a4dded','NC':'red','Other':'green','NA':'#FFEF00'},symbol='type', symbol_map=markers, hover_name='group',
                    hover_data={'class': False, 'type':False})
  fig0.update_layout(template="none",  showlegend=True, legend=dict(y=0.0, itemsizing="constant",title=""), modebar=dict(orientation='h'))
  fig0.update_traces(marker=dict(size=5, line=dict(color='white', width=4)))
  fig0.update_traces(selector=dict(marker_color='#FFEF00'), marker=dict(line_color='black'))
#creates traces
  cc_reg_df = reg_df.iloc[:2, :]
  nc_reg_df = reg_df.iloc[2:, :]
  CCtrace=go.Scatter3d(x=cc_reg_df[x_vals],y=cc_reg_df[y_vals],z=cc_reg_df[z_vals], mode='lines',showlegend=False,line=dict(color='blue'),hoverinfo='skip')
  NCtrace=go.Scatter3d(x=nc_reg_df[x_vals],y=nc_reg_df[y_vals],z=nc_reg_df[z_vals], mode='lines',showlegend=False,line=dict(color='red'),hoverinfo='skip')
#conditional statement that adds or removes regressions depending - ends function
  if CC_reg==True and NC_reg==False: ##just CC regs
    fig0.add_traces(CCtrace)
    return gr.update(value=fig0), gr.update(value="Update 3D Regression", visible=True)
  elif CC_reg==False and NC_reg==True: ##just NC regs
    fig0.add_traces(NCtrace)
    return gr.update(value=fig0), gr.update(value="Update 3D Regression", visible=True)
  elif CC_reg==True and NC_reg==True: ##both
    fig0.add_traces([CCtrace, NCtrace])
    return gr.update(value=fig0), gr.update(value="Update 3D Regression", visible=True)
  else: # CC_reg==False and NC_reg==False: ##neither
    return gr.update(value=fig0), gr.update(value="Update 3D Regression", visible=False)