library(shiny)
library(shinyjs)
library(bslib)
library(dplyr)
library(ggplot2)
library(readxl)
library(htmlwidgets)
library(shinydashboard)
library(neuralnet)
library(rsample)
options(width = 150)
options(digits = 4, scipen = 1000000000)
options(shiny.maxRequestSize=30*1024^2)



ui <- fluidPage(
  theme = bs_theme(version = 5, bootswatch = "spacelab"),
  useShinyjs(),  # Initialize shinyjs
  titlePanel("PtteM Data Science"),
  tags$head(tags$link(rel = "stylesheet", href="https://fonts.googleapis.com/css?family=Montserrat:100,300,400,700&display=swap"),
            tags$style(HTML("
        body, h1, h2, h3, h4, h5, h6, .nav, p, a, .shiny-input-container {
        font-family: 'Montserrat'; /* Font type for the title attribute */
        font-weight: 385;
        color: #007c9e !important;
      }
        * {
        font-family: 'Montserrat', sans-serif;
        font-weight: 385; 
        color: #195576; /* Blue color */
      }
        body { 
        background-color: #f7f7f7; /* Light gray background */
        }
      .icon-btn {
        border: 1px solid #0d6efd; /* Example border: solid, 2 pixels, #555 color */
        border-radius: 15%; /* Circular border */
        color: #00969e; /* Icon color */
        font-family: 'Montserrat'; /* Font type for the title attribute */
        font-weight: 385;
        background-color: #f7f7f7;
        padding: 125px; /* Space around the icon */
        margin: 25px; /* Space around the button */
        font-size: 24px; /* Icon size */
        box-shadow: 0 2px 4px rgba(0,0,0,0.2);
      }
      .icon-btn:hover {
        color: #00969e; /* Icon color on hover */
        border-color: #007c9e;
        background-color: #ebfbfd;/* Border color on hover */
      }
           /* Add custom styles here */
      .shiny-input-container {
        margin-bottom: 15px;
      }
      .box {
        border: 1px solid #ddd;
        padding: 20px;
        border-radius: 50px;
        margin-bottom: 200px;
        gap: 200px;
        align-items: center;
      }
    #statsTable_wrapper {
      margin: 0 auto;
    }
    .shiny-output-error {
    border: 1px solid #FF0000; /* Red border on error */
    }
      /* If you want to change the font size of the tooltip, you can add custom CSS for the 'title' attribute's default styling. */
    "))),
  tags$head(
    # Include JavaScript to reload the page
    tags$script(HTML("
    document.addEventListener('DOMContentLoaded', function() {
    document.getElementById('myElement').style.color = '#0d6efd'; // Change to your desired color
  });
"))
  ),
  tags$head(
    tags$script(HTML("
      function reloadPage() {
        window.location.reload();
      }
    "))
  ),
  # Refresh button that calls the JavaScript function
  actionButton("refresh", "Refresh Analysis", onclick = "reloadPage();"),
  # Help Text or Information for the user
  helpText("Bu uygulama ile metin analizi başlığı altındaki veri bilimi fonksiyonlarına erişebilirsiniz."),
  #Neural Networks
  h2("Neural Networks Section"),
  tabsetPanel(
    tabPanel("Perceptron Model",
             sidebarLayout(
               sidebarPanel(
                 fileInput("perc_input", "Choose CSV/XLSX/XSX File", accept = c(".csv, .xlsx, .xsx")),
                 uiOutput("target_perc"), # Dynamically generate UI for selecting target variable
                 uiOutput("predictors_perc"), # Dynamically generate UI for selecting predictor variables
                 sliderInput("dataSplitperc", 
                             "Data Split Ratio",
                             min = 0.1,
                             max = 0.9,
                             value = 0.7,  # Default value, for instance, 70% for training and 30% for testing
                             step = 0.05,
                             ticks = FALSE,
                             animate = TRUE),
                 actionButton("train_perceptron", "Train Perceptron Model"),
                 HTML("<div>
  <h2>Perceptron Modeli</h2>
  <p>Perceptron modeli, doğrusal olarak ayrılabilir veri kümeleri için basit bir denetimli öğrenme algoritmasıdır. Bu model, girdi ve çıktılar arasındaki ilişkiyi öğrenmek için kullanılır ve sınıflandırma problemlerinde yaygın olarak tercih edilir.</p>
  
  <h3>Kullanım Adımları:</h3>
  <ol>
    <li><strong>Veri Dosyası Yükleme:</strong> <code>fileInput</code> aracı ile CSV, XLSX veya XSX formatlarında veri dosyanızı yükleyin.</li>
    <li><strong>Hedef ve Öngörücülerin Seçimi:</strong> Dinamik olarak oluşturulan UI üzerinden hedef değişken ve öngörücü değişken(ler)inizi seçin.</li>
    <li><strong>Veri Bölme Oranı:</strong> <code>sliderInput</code> ile veri bölme oranını ayarlayın (örneğin, %70 eğitim, %30 test).</li>
    <li><strong>Modeli Eğit:</strong> <code>Train Perceptron Model</code> butonu ile perceptron modelinizi eğitin.</li>
  </ol>

  <h3>Model Özeti ve Kullanıcı Etkileşimi:</h3>
  <p>Kullanıcılar modeli eğittikten sonra, model özetini ve eğitim sonuçlarını görebilirler. Modelin performansı, çapraz doğrulama yöntemiyle değerlendirilir.</p>

  <h3>Uygulama Alanları:</h3>
  <p>Perceptron modeli, metin sınıflandırma, görüntü tanıma ve basit doğrusal ayrım gerektiren diğer makine öğrenmesi görevlerinde kullanılabilir.</p>

  <h3>Sonuçların Yorumlanması:</h3>
  <p>Eğitilen modelin başarısı, doğruluk oranı ve diğer performans metrikleriyle değerlendirilir. Modelin ayrıntılı özetinde, ağırlıklar, yanlılık ve öğrenme oranı gibi parametreler gösterilir.</p>
</div>")
                 
               ),
               mainPanel(
                 tabsetPanel(
                   tabPanel("Model Summary",verbatimTextOutput("model_summary")),
                 )
               )
             )
    ),
    tabPanel("Multilayer Perceptron",
             
             sidebarLayout(
               sidebarPanel(
                 fileInput("mlp_fileInput", "Choose CSV/XLSX/XSX File", accept = c(".csv", ".xlsx", ".xsx")),
                 uiOutput("mlp_preprocessUI"),
                 numericInput("mlp_hiddenLayers", "Number of Hidden Layers", value = 1),
                 numericInput("mlp_neurons", "Neurons in Hidden Layer", value = 5),
                 numericInput("mlp_epochs", "Number of Epochs", value = 100),
                 actionButton("mlp_trainButton", "Train MLP Model"),
                 HTML("<div>
  <h2>Çok Katmanlı Perseptron Modeli</h2>
  <p>Çok katmanlı perseptron modeli, derin öğrenme ve yapay sinir ağlarının temel yapı taşlarından biridir. Bu model, karmaşık veri yapılarını öğrenebilme ve tahmin etme yeteneğiyle ön plana çıkar.</p>
  
  <h3>Kullanım Adımları:</h3>
  <ol>
    <li><strong>Veri Dosyası Yükleme:</strong> <code>fileInput</code> aracı ile CSV, XLSX veya XSX formatlarında veri dosyanızı yükleyin.</li>
    <li><strong>Ön İşleme ve Değişken Seçimi:</strong> Dinamik olarak oluşturulan UI üzerinden hedef değişken, öngörücü değişken(ler) ve koşullu değişken seçin.</li>
    <li><strong>Model Parametreleri:</strong> Gizli katman sayısı, bir gizli katmandaki nöron sayısı ve dönem sayısı gibi model parametrelerini ayarlayın.</li>
    <li><strong>Modeli Eğit:</strong> <code>Train MLP Model</code> butonu ile çok katmanlı perceptron modelinizi eğitin.</li>
  </ol>

  <h3>Model Çıktısı ve Değerlendirme:</h3>
  <p>Model eğitimi tamamlandıktan sonra, eğitim sürecini ve modelin performansını gösteren grafikler ve özet metinler kullanıcıya sunulur. Model, verilen parametrelere göre en iyi yapılandırmayı öğrenmeye çalışır.</p>

  <h3>Uygulama Alanları:</h3>
  <p>Çok katmanlı perseptron modelleri, görüntü ve ses işleme, metin sınıflandırma ve finansal tahminler gibi geniş bir uygulama alanına sahiptir.</p>

  <h3>Sonuçların Yorumlanması:</h3>
  <p>Modelin başarımı, hata oranları, adım sayısı ve ağırlık dağılımları üzerinden değerlendirilir. Eğitim sürecinde elde edilen ağırlık değerleri, modelin öğrenme kapasitesini ve veri üzerindeki genelleme yeteneğini gösterir. Ayrıca, modelin gerçek dünya verileri üzerindeki performansını test etmek için ayrı bir test veri seti kullanılması önerilir.</p>
</div>"),
               ),
               mainPanel(
                 tabsetPanel(
                   tabPanel("Multilayer Output", plotOutput("mlp_trainingPlot", width = "100%", height = "700px")),
                   tabPanel("Evaluation", verbatimTextOutput("mlp_evaluation")),
                   tabPanel("GW Plot", plotOutput("mlp_gwplot", width = "100%", height = "700px"))
                 )
               )
             )
    ),
    
  )
)



server <- function(input, output, session) {
  
  read_data <- function(filepath) {
    ext <- tools::file_ext(filepath)
    if (ext == "csv") {
      read.csv(filepath, stringsAsFactors = FALSE)
    } else if (ext == "xlsx") {
      readxl::read_excel(filepath)
    } else {
      stop("Invalid file format. Please select a CSV or XLSX file.")
    }
  }
  
  clean_column_names <- function(dataframe) {
    colnames(dataframe) <- gsub("[^[:alnum:]_]", "", make.names(colnames(dataframe), unique = TRUE))
    return(dataframe)
  }
  
  ##Neural Networks
  ###Perceptron
  # Reactive expression to read and preprocess the dataset
  dataperc <- reactive({
    req(input$perc_input)
    inFile <- input$perc_input
    
    # Read the file based on its type
    if (grepl("\\.csv$", inFile$name)) {
      data <- read.csv(inFile$datapath, stringsAsFactors = FALSE)
    } else if (grepl("\\.(xlsx|xls)$", inFile$name)) {
      data <- readxl::read_xlsx(inFile$datapath)
    } else {
      stop("Unsupported file type")
    }
    
    # Clean up column names
    names(data) <- make.names(names(data), unique = TRUE)
    return(data)
  })
  
  
  # Generate UI for selecting the target variable
  output$target_perc <- renderUI({
    req(dataperc()) # Ensure data is loaded
    
    # Create a list of UI elements to return
    ui_elements <- tagList(
      # Dropdown for selecting the target variable
      selectInput("target_variable", "Select Target Variable", choices = names(dataperc())),
      # Hint for the user with an emoji
      tags$p(HTML("Please upload a categorical variable &#127936; &#128132; &#127828; &#128241;")) # Smiling face emoji
    )
    
    return(ui_elements)
  })
  
  
  # Generate UI for selecting predictor variables
  output$predictors_perc <- renderUI({
    req(dataperc())
    selectInput("predictors", "Select Predictor Variables", multiple = TRUE, choices = names(dataperc()), selected = names(dataperc())[1])
  })
  
  # Train the Perceptron model
  observeEvent(input$train_perceptron, {
    req(dataperc(), input$target_variable, input$predictors)
    data <- dataperc()
    data <- na.omit(data)
    
    # Ensure the target variable is a factor
    data[[input$target_variable]] <- as.factor(data[[input$target_variable]])
    
    #target_variable <- input$target_variable
    #predictors <- input$predictors
    
    # Split data into training and testing sets
    set.seed(123)
    split_ratio <- input$dataSplitperc
    trainingIndex <- caret::createDataPartition(data[[input$target_variable]], p = split_ratio, list = FALSE)
    trainingData <- data[trainingIndex, ]
    testData <- data[-trainingIndex, ]
    
    # Define control using a cross-validation approach
    trainControl <- trainControl(method = "cv", number = 10)
    # Assuming variable names are now valid R identifiers without special characters
    formula <- as.formula(paste(input$target_variable, "~", paste(input$predictors, collapse = "+")))
    perceptronModel <- caret::train(formula, data = trainingData, method = "lvq", preProcess = "scale", trControl = trainControl)
    
    # Model summary
    output$model_summary <- renderPrint({
      perceptronModel
    })
    
  })
  
  ##Multiple Perceptron Model
  # Reactive expression for data input
  dataMLP <- reactive({
    req(input$mlp_fileInput)
    inFile <- input$mlp_fileInput
    if (grepl("\\.csv$", inFile$name)) {
      read.csv(inFile$datapath, stringsAsFactors = FALSE)
    } else if (grepl("\\.(xlsx|xls)$", inFile$name)) {
      readxl::read_xlsx(inFile$datapath)
    } else {
      stop("Unsupported file type")
    }
  })
  
  output$mlp_preprocessUI <- renderUI({
    req(dataMLP())
    varNames <- names(dataMLP())
    tagList(
      selectInput("mlp_targetVariable", "Select Target Variable", choices = varNames),
      selectInput("mlp_variables", "Select Predictor Variables", choices = varNames, multiple = TRUE),
      selectInput("mlp_covariate", "Select Covariate Variable", choices = varNames),
      tags$p(HTML("Please select Covariate Variable from Predictor Variables"))
    )
  })
  
  observeEvent(input$mlp_trainButton, {
    req(dataMLP(), input$mlp_targetVariable, input$mlp_variables)
    data <- dataMLP()
    data <- na.omit(data)
    
    # Define the formula for the neural network
    formula <- as.formula(paste(input$mlp_targetVariable, "~", paste(input$mlp_variables, collapse = "+")))
    
    # Train the neural network model
    nn <- neuralnet(formula, data, hidden = c(input$mlp_neurons), linear.output = FALSE, threshold = 0.01, stepmax = input$mlp_epochs)
    
    # Plot the neural network
    output$mlp_trainingPlot <- renderPlot({
      plot(nn,rep = "best")
    })
    
    
    # Print the result matrix of the neural network
    output$mlp_evaluation <- renderPrint({
      print(nn$result.matrix)
      # Neural Network Model Performance Summary
      cat("\nNeural Network Model Performance Summary:\n")
      
      # If the error is not within a reasonable range, you could give more context:
      if (nn$result.matrix["error", ] > 200) {
        cat("The model error of", nn$result.matrix["error", ], "is above the expected threshold. This may indicate that the model does not fit the data well. Consider collecting more data, feature engineering, or adjusting the model's complexity.\n")
      } else {
        cat("The model error of", nn$result.matrix["error", ], "is within the acceptable range, suggesting the model has learned the patterns from the data effectively.\n")
      }
      
      # Comment on the number of steps
      cat("The model took", nn$result.matrix["steps", ], "steps to converge, which indicates ", ifelse(nn$result.matrix["steps", ] < 3000, "an efficient training process.", "that the maximum set steps were reached without sufficient convergence."), "\n")
      
      # Comment on the weights
      cat("The model's weights have been optimized through training. Each weight reflects the importance of the corresponding input feature for predicting the output. For instance, the weight for 'Price' to the first hidden neuron is", nn$result.matrix["Price.to.1layhid1", ], ".\n")
      
      # Mention the threshold
      cat("The threshold for stopping the training was set to", nn$result.matrix["reached.threshold", ], ", and the model reached an error close to this threshold, which is a good sign of model convergence.\n")
      
      # Add a note on the usage of the model
      cat("This trained model can now be used to make predictions on new data. It's important to validate the model's performance on a separate test set to ensure its predictive accuracy.\n")
    })
    
    output$mlp_gwplot <- renderPlot({
      req(input$mlp_covariate) # Make sure input$mlp_variables is available
      selected_var <- input$mlp_covariate # This should be a vector of selected variable names
      if (length(selected_var) == 1) { # gwplot may only accept a single variable
        gwplot(nn, selected.covariate = selected_var, min = -2.5, max = 5)
      } else {
        cat("Please select a single predictor variable to view its weight distribution.")
      }
    })
    
  })
  
}

shinyApp(ui, server)