library(shiny)
library(shinyjs)
library(bslib)
library(dplyr)
library(ggplot2)
library(tm)
library(SnowballC)
library(plotly)
library(dplyr)
library(tidyr)
library(igraph)
library(ggraph)
library(reshape2)
library(SnowballC)
library(RColorBrewer)
library(syuzhet)
library(cluster)
library(Rtsne)
library(umap)
library(MASS)
library(koRpus)
library(openxlsx)
library(tools)
library(shinyWidgets)
#library(readxl)
library(scales)
library(caret)
library(BBmisc)
library(glmnet)
library(pROC)
library(ROCR)
library(car)
library(ResourceSelection)
library(tree)
library(ggplotify)
library(lmtest)
library(gridExtra)
library(patchwork)
library(caret)
library(randomForest)
library(gbm)
library(earth)
library(broom)
library(rlang)
library(ggdendro)
library(pastecs)
library(forecast)
library(scales)
if (!require("caret")) install.packages("caret", dependencies = TRUE)
library(caret)
library(BBmisc)
library(glmnet)
library(pROC)
library(ROCR)
library(car)
library(ResourceSelection)
library(tree)
library(ggplotify)
library(lmtest)
library(gridExtra)
library(patchwork)
library(caret)
library(randomForest)
library(gbm)
library(earth)
library(broom)
library(rlang)
library(ggdendro)
library(pastecs)
library(dbscan)
library(fpc)
library(factoextra)
library(scales)
library(openxlsx)
library(arules)
library(arulesViz)
library(viridis)
library(kohonen)
library(purrr)
library(rvest)
library(Rtsne)
library(shinydashboard)
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."),
  #Unupervised Learning
        h2("Unsupervised Learning Section"),
        tabsetPanel(
          tabPanel("Principal Component Analysis",
                   sidebarLayout(
                     sidebarPanel(
                       fileInput("pcainput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
                       # Conditional panel for group selection
                       uiOutput("groupSelectUI"),
                       actionButton("loadpca", "Load Data"),
                       selectInput("independentVarpca", "Select Columns", choices = NULL, multiple = T),
                       actionButton("runpca", "Run PCA"),
                       HTML("<div>
  <h2>Ana Bileşen Analizi (PCA) Paneli</h2>
  
  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
  <p>Ana Bileşen Analizi (PCA), veri setlerindeki boyutluluğu azaltmak ve en önemli özellikleri belirlemek için kullanılan bir yöntemdir. Bu panel, kullanıcıların veri setlerindeki ana bileşenleri analiz etmelerine, önemli özellikleri keşfetmelerine ve veri setlerinin görselleştirilmesine olanak tanır.</p>
  
  <h3>Kullanım Adımları:</h3>
  <ol>
    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
    <li><strong>Bağımsız Değişkenlerin Seçimi:</strong> Analizde kullanılacak bağımsız değişkenleri seçin.</li>
    <li><strong>PCA Çalıştırma:</strong> Ana bileşen analizini çalıştırın ve sonuçları inceleyin.</li>
  </ol>
  
  <h3>Kullanıcı Etkileşimi:</h3>
  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri seçebilir ve PCA sonuçlarını detaylı bir şekilde inceleyebilir. Panel, boyut indirgeme ve özellik seçimi konularında kullanıcıya rehberlik eder.</p>
  
  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
  <p>PCA, yüksek boyutlu veri setlerinin anlaşılmasını ve yorumlanmasını kolaylaştırır. Özellikle, çok sayıda değişken içeren veri setlerinde, önemli özellikleri belirlemek ve veri setlerini daha basit hale getirmek için kullanılır.</p>
  
  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
  
  <h3>Sonuçların Yorumlanması:</h3>
  <p>PCA sonuçları, veri setindeki değişkenler arasındaki ilişkileri ve veri setinin ana bileşenlerini ortaya koyar. Bu, veri setinin daha basit bir şekilde anlaşılmasını ve analiz edilmesini sağlar.</p>
  
  <ul>
    <li><strong>Model Özeti:</strong> PCA modelinin temel özellikleri ve bileşenlerinin açıkladığı varyans miktarı hakkında bilgiler sunar.</li>
    <li><strong>Bi Plot:</strong> Ana bileşenlerin ve değişkenlerin birbirleriyle olan ilişkisini görsel olarak gösterir. Bu, hangi değişkenlerin PCA sonuçlarını en çok etkilediğini anlamada yardımcı olur.</li>
  </ul>
  
  <p>PCA paneli, kullanıcıların veri setlerindeki temel yapıyı keşfetmelerine ve önemli özellikleri belirlemelerine yardımcı olan kapsamlı bir araçtır.</p>
</div>")
                     ),
                     mainPanel(
                       tabsetPanel(
                         tabPanel("Data Summary", verbatimTextOutput("dataSummarypca")),
                         tabPanel("PCA Output",
                                  tabsetPanel(
                                    tabPanel("Run PCA", verbatimTextOutput("runpca")),
                                    tabPanel("Bi Plot Columns", plotlyOutput("biPlotpca", width = "100%", height = "625px")),
                                  )
                         )
                       )
                     )
                   )
          ),
          tabPanel("K-Means Clustering",
                   sidebarLayout(
                     sidebarPanel(
                       fileInput("kmcinput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
                       actionButton("loadkmc", "Load Data"),
                       selectInput("targetkmc", "Select First Column", choices = NULL),
                       selectInput("independentVarkmc", "Select Second Column", choices = NULL),
                       numericInput("numCenterskmc", "Number of Clusters:", value = 3, min = 2),
                       actionButton("runkmc", "Run K-Means"),
                       HTML("<div>
  <h2>K-Ortalama Kümeleme Paneli</h2>
  
  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
  <p>K-Ortalama Kümeleme, veri setlerini benzer özelliklere göre gruplara ayırmak için kullanılan bir yöntemdir. Bu panel, kullanıcıların veri setlerindeki kümeleri analiz etmelerine, farklı grupları keşfetmelerine ve veri setlerinin kümeleme sonuçlarını görselleştirmelerine olanak tanır.</p>
  
  <h3>Kullanım Adımları:</h3>
  <ol>
    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
    <li><strong>Değişkenlerin Seçimi:</strong> Kümelemede kullanılacak değişkenleri seçin.</li>
    <li><strong>Küme Sayısı Belirleme:</strong> Oluşturulacak kümelerin sayısını belirleyin.</li>
    <li><strong>K-Ortalama Kümeleme Çalıştırma:</strong> K-Ortalama Kümeleme algoritmasını çalıştırın ve sonuçları inceleyin.</li>
  </ol>
  
  <h3>Kullanıcı Etkileşimi:</h3>
  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri ve küme sayısını belirleyebilir ve K-Ortalama Kümeleme sonuçlarını detaylı bir şekilde inceleyebilir. Panel, kümeleme ve gruplandırma konularında kullanıcıya rehberlik eder.</p>
  
  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
  <p>K-Ortalama Kümeleme, veri setlerindeki doğal gruplandırmaları keşfetmek ve veri içgörülerini artırmak için yaygın olarak kullanılır. Özellikle, müşteri segmentasyonu, hedefleme ve benzer gruplar içindeki eğilimleri anlama gibi alanlarda tercih edilir.</p>
  
  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
  
  <h3>Sonuçların Yorumlanması:</h3>
  <p>K-Ortalama Kümeleme sonuçları, veri setindeki grupların merkezlerini, her bir kümenin içerdiği gözlem sayısını ve kümeler arasındaki benzerlik/dissimilarity ölçülerini içerir. Bu, veri setinin daha derin bir şekilde anlaşılmasını ve stratejik kararlar alınmasını sağlar.</p>
  
  <ul>
    <li><strong>Model Özeti:</strong> K-Ortalama Kümeleme modelinin temel özellikleri ve kümelerin özellikleri hakkında bilgiler sunar.</li>
    <li><strong>Kümeleme Grafiği:</strong> Oluşturulan kümelerin ve merkezlerinin görsel bir temsilidir. Bu, hangi gözlemlerin hangi kümeye ait olduğunu anlamada yardımcı olur.</li>
    <li><strong>Silüet Sonuçları:</strong> Kümeleme kalitesinin bir göstergesi olan silüet skorlarını içerir. Bu skorlar, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını gösterir.</li>
  </ul>
  
  <p>K-Ortalama Kümeleme paneli, kullanıcıların veri setlerindeki doğal gruplandırmaları keşfetmeler

ine ve önemli özellikleri belirlemelerine yardımcı olan kapsamlı bir araçtır.</p>
</div>")
                     ),
                     mainPanel(
                       tabsetPanel(
                         tabPanel("Data Summary", verbatimTextOutput("dataSummarykmc")),
                         tabPanel("K-Means Output",
                                  tabsetPanel(
                                    tabPanel("Run K-Means", verbatimTextOutput("runkmc")),
                                    tabPanel("Clustering Plot", plotlyOutput("clusteringPlotkmc", width = "100%", height = "625px")),
                                    tabPanel("Silhouttte Results", plotlyOutput("silhouettePlotkmc", width = "100%", height = "625px"))
                                  )
                         )
                       )
                     )
                   )
          ),
          tabPanel("Hierarchical Clustering",
                   sidebarLayout(
                     sidebarPanel(
                       fileInput("hcinput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
                       actionButton("loadhc", "Load Data"),
                       selectInput("independentVarhc", "Select the Columns", choices = NULL, multiple = TRUE),
                       numericInput("numCentershc", "Number of Clusters:", value = 2, min = 2, max = 8),
                       actionButton("runavehc", "Run Average Linkage"),
                       actionButton("runcenhc", "Run Centroid Linkage"),
                       actionButton("runwddhc", "Run Ward D2 Linkage"),
                       actionButton("runmchc", "Run Mcquity Linkage"),
                       HTML("<div>
  <h2>Hiyerarşik Kümeleme Paneli</h2>
  
  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
  <p>Hiyerarşik Kümeleme, veri noktalarını adım adım birleştirerek veya bölererek hiyerarşik bir kümeler dizisi oluşturan bir yöntemdir. Bu panel, kullanıcıların veri setlerindeki doğal gruplamaları keşfetmelerine, farklı kümeleme yöntemlerini denemelerine ve sonuçları görselleştirmelerine olanak tanır.</p>
  
  <h3>Kullanım Adımları:</h3>
  <ol>
    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
    <li><strong>Değişkenlerin Seçimi:</strong> Kümelemede kullanılacak değişkenleri seçin.</li>
    <li><strong>Küme Sayısı Belirleme:</strong> Oluşturulacak kümelerin sayısını belirleyin.</li>
    <li><strong>Kümeleme Yöntemlerini Çalıştırma:</strong> Ortalama, merkez, Ward D2 veya Mcquity bağlantı yöntemlerinden birini seçerek çalıştırın.</li>
  </ol>
  
  <h3>Kullanıcı Etkileşimi:</h3>
  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri ve küme sayısını belirleyebilir, farklı hiyerarşik kümeleme yöntemlerini deneyebilir ve sonuçları detaylı bir şekilde inceleyebilir.</p>
  
  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
  <p>Hiyerarşik Kümeleme, özellikle müşteri segmentasyonu, gen ifadesi analizi ve sosyal ağ analizi gibi alanlarda kullanılır. Bu yöntem, veri setlerindeki doğal gruplamaları ve ilişkileri keşfetmek için önemli bir araçtır.</p>
  
  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
  
  <h3>Sonuçların Yorumlanması:</h3>
  <p>Hiyerarşik Kümeleme sonuçları, dendrogramlar ve siluet analizleri aracılığıyla sunulur. Dendrogramlar, veri noktaları arasındaki ilişkilerin ve gruplamaların hiyerarşik yapısını gösterirken, siluet analizleri, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını değerlendirir.</p>
  
  <ul>
    <li><strong>Model Özeti:</strong> Seçilen kümeleme yönteminin temel özellikleri ve kümelerin özellikleri hakkında bilgiler sunar.</li>
    <li><strong>Dendrogram:</strong> Veri noktaları arasındaki ilişkilerin ve gruplamaların hiyerarşik yapısını gösterir. Her bir kümeleme yöntemi için ayrı dendrogramlar sunulur.</li>
    <li><strong>Siluet Sonuçları:</strong> Kümeleme kalitesinin bir göstergesi olan siluet skorlarını içerir. Bu skorlar, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını gösterir.</li>
  </ul>
  
  <p>Hiyerarşik Kümeleme paneli, kullanıcıların veri setlerindeki doğal gruplamaları keşfetmelerine ve önemli özellik

leri belirlemelerine yardımcı olan kapsamlı bir araçtır.</p>
</div>")
                     ),
                     mainPanel(
                       tabsetPanel(
                         tabPanel("Data Summary", verbatimTextOutput("dataSummaryhc")),
                         tabPanel("Hierarchical Clustering",
                                  tabsetPanel(
                                    tabPanel("Average Linkage",plotlyOutput("averageDendrogram", width = "100%", height = "825px")),
                                    tabPanel("Silhoutte Results", plotlyOutput("silhouettePlotHCave", width = "100%", height = "625px")),
                                    tabPanel("Centroid Linkage",plotlyOutput("centroidDendrogram", width = "100%", height = "825px")),
                                    tabPanel("Silhoutte Results", plotlyOutput("silhouettePlotHCcen", width = "100%", height = "625px")),
                                    tabPanel("Ward D2 Linkage", plotlyOutput("wdd2Dendrogram", width = "100%", height = "825px")),
                                    tabPanel("Silhoutte Results", plotlyOutput("silhouettePlotHCwdd2", width = "100%", height = "625px")),
                                    tabPanel("Mcquity Linkage", plotlyOutput("mcquDendrogram", width = "100%", height = "825px")),
                                    tabPanel("Silhoutte Results", plotlyOutput("silhouettePlotHCmc", width = "100%", height = "625px"))
                                  )
                         )
                       )
                     )
                   )
          ),
          tabPanel("DBSCAN Clustering",
                   sidebarLayout(
                     sidebarPanel(
                       fileInput("dbscaninput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
                       actionButton("loaddbscan", "Load Data"),
                       selectInput("independentVardbscan", "Select Columns", choices = NULL, multiple = T),
                       actionButton("rundbscandist", "Run kNN"),
                       actionButton("rundbscan", "Run DBSCAN"),
                       numericInput("numepsdbscan", "Type Optimum Epsilon:", value = 0),
                       HTML("<div>
  <h2>DBSCAN Kümeleme Paneli</h2>
  
  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
  <p>DBSCAN (Yoğunluk Tabanlı Mekansal Kümeleme Uygulamaları ile Gürültü), veri noktalarını yoğunluk temelinde kümeler halinde gruplandıran bir kümeleme algoritmasıdır. Bu panel, kullanıcıların yoğunluk tabanlı kümeleri keşfetmelerine ve gürültülü veri noktalarını ayırt etmelerine olanak tanır.</p>
  
  <h3>Kullanım Adımları:</h3>
  <ol>
    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
    <li><strong>Değişkenlerin Seçimi:</strong> Kümelemede kullanılacak değişkenleri seçin.</li>
    <li><strong>kNN Mesafesinin Çalıştırılması:</strong> Optimum epsilon değerini belirlemek için kNN mesafesini çalıştırın.</li>
    <li><strong>DBSCAN Kümelemesini Çalıştırma:</strong> Belirlenen epsilon değeriyle DBSCAN kümelemesini çalıştırın.</li>
  </ol>
  
  <h3>Kullanıcı Etkileşimi:</h3>
  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri seçebilir, optimum epsilon değerini belirleyebilir ve DBSCAN algoritmasını kullanarak kümeleme yapabilir.</p>
  
  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
  <p>DBSCAN, özellikle düzensiz şekillerdeki kümeleri tanıyabilme ve aykırı değerleri (gürültüyü) dışlayabilme yeteneği nedeniyle, veri madenciliği, görüntü analizi ve biyoinformatik gibi alanlarda kullanılır.</p>
  
  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
  
  <h3>Sonuçların Yorumlanması:</h3>
  <p>DBSCAN Kümeleme sonuçları, kNN mesafe grafiği, kümeleme özeti, kümeleme görselleştirmesi ve siluet analizi aracılığıyla sunulur. kNN mesafe grafiği, optimum epsilon değerinin belirlenmesine yardımcı olur. Kümeleme özeti, oluşturulan kümeler ve her birindeki veri noktası sayısını içerir. Kümeleme görselleştirmesi, oluşturulan kümelerin dağılımını gösterir. Siluet analizi, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını değerlendirir.</p>
  
  <ul>
    <li><strong>kNN Mesafe Grafiği:</strong> Optimum epsilon değerinin belirlenmesine yardımcı olan bir grafiği içerir.</li>
    <li><strong>Kümeleme Özeti:</strong> Oluşturulan kümelerin sayısını ve her birindeki veri noktası sayısını gösterir.</li>
    <li><strong>Kümeleme Görselleştirmesi:</strong> Oluşturulan kümelerin mekansal dağılımını gösterir.</li>
    <li><strong>Siluet Analizi:</strong> Kümeleme kalitesinin bir göstergesi olan siluet skorlarını içerir. Bu skorlar, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını gösterir.</li>
  </ul>
  
  <p>DBSCAN Kümeleme Paneli, veri setlerindeki doğal kümeleri keşfetmek ve veri içgörülerini elde etmek için güçlü bir araçtır.</p>
</div>")
                     ),
                     mainPanel(
                       tabsetPanel(
                         tabPanel("Data Summary", verbatimTextOutput("dataSummarydbscan")),
                         tabPanel("DBSCAN Output",
                                  tabsetPanel(
                                    tabPanel("kNN Plot", plotOutput("rundbscandist", width = "100%", height = "625px")),
                                    tabPanel("Run DBSCAN", verbatimTextOutput("rundbscan")),
                                    tabPanel("Clustering Plot", plotlyOutput("clusteringPlotdbscan", width = "100%", height = "625px")),
                                    tabPanel("Silhoutte Result", plotlyOutput("silhouettePlotdbscan", width = "100%", height = "625px"))
                                  )
                         )
                       )
                     )
                   )
          ),
          tabPanel("Associated Rule Learning",
                   sidebarLayout(
                     sidebarPanel(
                       fileInput("arlinput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
                       actionButton("loadarl", "Load Data"),
                       selectInput("targetarl", "Select ID Column", choices = NULL),
                       selectInput("itemsColumn", "Select Basket Column", choices = NULL),
                       actionButton("runarl", "Run ARL"),
                       HTML("<div>
  <h2>İlişkisel Kural Öğrenimi Paneli</h2>
  
  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
  <p>İlişkisel Kural Öğrenimi (ARL), veri setlerindeki öğeler arasındaki ilişkileri ve sıklıkla birlikte gerçekleşen öğe setlerini keşfetmek için kullanılan bir veri madenciliği tekniğidir. Bu panel, Apriori algoritmasını kullanarak ilişkisel kuralları belirlemeye ve bu kuralların önemini değerlendirmeye yardımcı olur.</p>
  
  <h3>Kullanım Adımları:</h3>
  <ol>
    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
    <li><strong>Değişkenlerin Seçimi:</strong> Analiz için ID ve sepet sütunlarını seçin.</li>
    <li><strong>ARL Çalıştırma:</strong> İlişkisel kural öğrenimini başlatmak için 'Run ARL' düğmesine tıklayın.</li>
  </ol>
  
  <h3>Kullanıcı Etkileşimi:</h3>
  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri seçebilir ve ARL algoritmasını çalıştırabilir. Elde edilen kurallar, önem sırasına göre sıralanır ve kullanıcıya sunulur.</p>
  
  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
  <p>ARL, perakende satış analizleri, ürün öneri sistemleri ve müşteri satın alma davranışlarının incelenmesi gibi alanlarda kullanılır. Bu yöntem, veri setlerindeki gizli ilişkileri ortaya çıkararak iş kararları için değerli içgörüler sağlar.</p>
  
  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
  
  <h3>Sonuçların Yorumlanması:</h3>
  <p>İlişkisel kural öğrenim sonuçları, madde frekans grafiği, Apriori algoritması çıktısı ve sıralı ARL çıktısı aracılığıyla sunulur. Madde frekans grafiği, veri setindeki öğelerin sıklığını gösterir. Apriori algoritması çıktısı, elde edilen kuralları ve bu kuralların destek, güven ve kaldıraç değerlerini içerir. Sıralı ARL çıktısı, kuralların önem sırasına göre sıralanmasını sağlar, bu da kullanıcıların en önemli kuralları kolaylıkla belirlemesine yardımcı olur.</p>
  
  <ul>
    <li><strong>Madde Frekans Grafiği:</strong> Veri setindeki öğelerin sıklığını gösterir.</li>
    <li><strong>Apriori Algoritması Çıktısı:</strong> Elde edilen kuralları ve bu kuralların destek, güven ve kaldıraç değerlerini içerir.</li>
    <li><strong>Sıralı ARL Çıktısı:</strong> Kuralların önem sırasına göre sıralanmasını sağlar.</li>
  </ul>
  
  <p>İlişkisel Kural Öğrenimi Paneli, veri setlerindeki ilişkisel kuralları keşfetmek ve veri içgörülerini elde etmek için güçlü bir araçtır

.</p>
</div>")
                     ),
                     mainPanel(
                       tabsetPanel(
                         tabPanel("ARL Plot", plotlyOutput("itemFreqPlot", width = "100%", height = "625px")),
                         tabPanel("Run Appriori", verbatimTextOutput("runarlapp")),
                         tabPanel("Sorted ARL Output", verbatimTextOutput("sortedARLOutput"))
                       )
                     )
                   )
          ),

          
        )

)

server <- function(input, output, session) {

  ##Unsupervised Learning
  ###Principal Component Analysis
  datapca <- reactiveVal(NULL)
  pca_model_reactive <- reactiveVal()
  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)
  }
  # Load and clean data
  observeEvent(input$loadpca, {
    req(input$pcainput)
    file <- input$pcainput
    if (!is.null(file)) {
      # Reading and cleaning data
      data_df <- read_data(file$datapath)
      data_df <- clean_column_names(data_df)
      # Setting the reactive value
      datapca(data_df)
      # Updating UI elements
      updateSelectInput(session, "independentVarpca", choices = colnames(data_df))
    }
  })
  
  output$dataSummarypca <- renderPrint({
    req(datapca())
    summary(datapca())
  }) 
  
  pca_reactive <- eventReactive(input$runpca, {
    req(datapca(), input$independentVarpca)
    if (length(input$independentVarpca) == 0) {
      return(NULL)
    }
    data_pca <- datapca() %>%
      dplyr::select(all_of(input$independentVarpca)) %>%
      na.omit()
    if (nrow(data_pca) < 10) {
      return(NULL)
    }
    pca_model <- prcomp(data_pca, scale = TRUE)
    pca_model_reactive(pca_model)
    pca_model
  })
  
  observeEvent(input$runpca, { 
    req(pca_reactive())
    output$runpca <- renderPrint({
      pca_result <- pca_reactive()
      
      print(pca_result)
      
      # Print the summary of PCA results
      pca_summary <- summary(pca_result)
      print(pca_summary)
      
      # Interpretation for the users
      cat("Principal Component Analysis (PCA) Summary:\n")
      cat("The 'Proportion of Variance' indicates how much information (variance) is captured by each principal component.\n")
      cat("The 'Cumulative Proportion' indicates the total variance captured by all the components up to that point.\n")
      cat("\nFor example, if the first two principal components capture 70% of the variance, it means that these two components together represent most of the variability in the data.\n")
      cat("This can be used to reduce the dimensionality of the data, by considering only the first few principal components that capture most of the variance.\n")
      
      # Holland's criteria for deciding how many PCs to retain
      cat("\nHolland's Criteria for Retaining Principal Components:\n")
      cat("1) Ignore components where the next PC offers little increase in total variance explained.\n")
      cat("2) Include PCs up to a predetermined total percent variance explained, such as 90%.\n")
      cat("3) Ignore components whose variance explained is less than 1 with a correlation matrix, or less than average variance explained with a covariance matrix.\n")
      cat("4) Ignore the last PCs whose variance explained is all roughly equal.\n")
      
      # Holland's Criteria Implementation
      cat("\nHolland's Criteria for Retaining Principal Components:\n")
      
      # Criterion 1: Ignore PCs with little increase in total variance explained
      variance_increases <- diff(pca_summary$importance["Proportion of Variance", ])
      significant_increase_index <- which(variance_increases > 0.01)  # Adjust the threshold as needed
      if (length(significant_increase_index) > 0) {
        cat("Criterion 1: Consider PCs up to index ", max(significant_increase_index), "\n")
      }
      
      # Criterion 2: Total percent variance explained, such as 90%
      cumulative_variance <- pca_summary$importance["Cumulative Proportion", ]
      sufficient_variance_index <- which(cumulative_variance >= 0.9)[1]
      if (!is.na(sufficient_variance_index)) {
        cat("Criterion 2: Consider PCs up to index ", sufficient_variance_index, " to explain 90% of variance.\n")
      }
      
      # Criterion 3: Ignore components with variance explained less than average
      average_variance <- mean(pca_summary$importance["Proportion of Variance", ])
      sufficient_variance_index <- which(pca_summary$importance["Proportion of Variance", ] >= average_variance)
      if (length(sufficient_variance_index) > 0) {
        cat("Criterion 3: Consider PCs with variance greater than the average ", round(average_variance, 2), "\n")
      }
      
      # Criterion 4: Ignore last PCs with roughly equal variance explained
      # Implementation can be subjective and depends on the context. Typically involves looking at a scree plot.
      cat("Criterion 4: This part is subjective and depends on how you want to prioritize or combine the criteria.\n")
      # Final recommendation based on Holland's Criteria
      cat("\nFinal Recommendation based on Holland's Criteria:\n")
      # Combine and interpret the criteria here. 
      cat("Final: This part is subjective and depends on how you want to prioritize or combine the criteria.\n")
    })
  })
  
  
  observeEvent(input$runpca, { 
    req(datapca(), input$independentVarpca)
    # Get the data
    data_for_pca <- datapca()
    
    # Run PCA only on complete cases to avoid NAs
    complete_data <- data_for_pca[complete.cases(data_for_pca[input$independentVarpca]), input$independentVarpca]
    pca_result <- prcomp(complete_data, scale = TRUE)
    
    # Generate the biplot
    output$biPlotpca <- renderPlotly({
      fviz_pca_biplot(pca_result, label = "var",
                      addEllipses=TRUE, ellipse.level=0.95,
                      ggtheme = theme_minimal()) %>%
        ggplotly() %>% layout(dragmode = "select")  # Enable selection mode in plotly
    })
  })
  
  
  
  
  
  ###K-Means Clustering
  datakmc <- reactiveVal(NULL)
  kmc_model_reactive <- reactiveVal()
  # Load and clean data
  observeEvent(input$loadkmc, {
    req(input$kmcinput)
    file <- input$kmcinput
    if (!is.null(file)) {
      # Reading and cleaning data
      data_df <- read_data(file$datapath)
      data_df <- clean_column_names(data_df)
      
      # Setting the reactive value
      datakmc(data_df)
      
      # Updating UI elements
      updateSelectInput(session, "targetkmc", choices = colnames(data_df))
      updateSelectInput(session, "independentVarkmc", choices = colnames(data_df))
    }
  })
  
  
  output$dataSummarykmc <- renderPrint({
    req(datakmc())
    summary(datakmc())
  }) 
  
  observeEvent(input$runkmc, {
    req(datakmc(), input$targetkmc, input$independentVarkmc)
    
    withProgress(message = 'Model is being trained...', value = 0, {
      # Increment progress
      incProgress(0.1)  # Initial progress
      data_kmc <- datakmc() %>%
        dplyr::select(input$targetkmc, input$independentVarkmc) %>%
        na.omit()
      
      # Early return if conditions are not met
      if (length(input$targetkmc) == 0) {
        output$modelOutputkmc <- renderPrint({ "Please select the first variable." })
        return()
      }
      
      if (length(input$independentVarkmc) == 0) {
        output$modelOutputkmc <- renderPrint({ "Please select the second variable." })
        return()
      }
      
      incProgress(0.3)  # Increment progress
      if (nrow(data_kmc) < 10) {
        output$modelOutputkmc <- renderPrint({ "Dataset is too small after removing NA values." })
        return()
      }
      incProgress(0.6)  # Increment progress
      # Partition the data
      
      
      # Fit the Random Forest model
      x <- data_kmc %>% dplyr::select(input$targetkmc, input$independentVarkmc)
      z <- scale(x)
      num_clusters <- input$numCenterskmc
      kmc_model <- kmeans(z, num_clusters, nstart = 20)
      kmc_model_reactive(kmc_model)
      
      # Augment data with cluster assignments
      data_kmc$cluster <- kmc_model$cluster
      
      # Model summary
      output$runkmc <- renderPrint({
        print(kmc_model)
        
      })
      
      # Finalize progress
      incProgress(1.0)  # Complete the progress
    })
  }) 
  
  output$clusteringPlotkmc <- renderPlotly({
    req(kmc_model_reactive(), input$targetkmc, input$independentVarkmc)
    
    # Get the k-means model
    kmc_model <- kmc_model_reactive()
    
    # Get the data and add cluster assignments
    data_kmc <- datakmc() %>%
      dplyr::select(input$targetkmc, input$independentVarkmc) %>%
      na.omit()
    
    # Ensure the k-means model is valid
    if (is.null(kmc_model)) {
      print("K-means model is not available.")
      return()
    }
    
    # Prepare data for fviz_cluster
    # fviz_cluster requires a kmeans object and data used for clustering
    # Make sure data_kmc and kmc_model correspond to each other
    fviz_cluster(kmc_model, data = data_kmc, stand = FALSE, geom = "point", 
                 ellipse.type = "convex", 
                 palette = "jco", 
                 ggtheme = theme_minimal())
  })
  
  output$silhouettePlotkmc <- renderPlotly({
    req(kmc_model_reactive(), input$targetkmc, input$independentVarkmc)
    
    # Retrieve the k-means model
    kmc_model <- kmc_model_reactive()
    
    # Retrieve the data
    data_kmc <- datakmc() %>%
      dplyr::select(input$targetkmc, input$independentVarkmc) %>%
      na.omit()
    
    # Create the silhouette object
    silhouette_info <- silhouette(kmc_model$cluster, dist(data_kmc))
    
    # Visualize the silhouette plot
    fviz_silhouette(silhouette_info) + 
      labs(title = "Silhouette Plot for K-Means Clustering")
  })
  
  ###Hierarchical Clustering
  datahc <- reactiveVal(NULL)
  # Load and clean data
  observeEvent(input$loadhc, {
    req(input$hcinput)
    file <- input$hcinput
    if (!is.null(file)) {
      # Reading and cleaning data
      data_df <- read_data(file$datapath)
      data_df <- clean_column_names(data_df)
      
      # Setting the reactive value
      datahc(data_df)
      
      # Updating UI elements
      updateSelectInput(session, "independentVarhc", choices = colnames(data_df))
    }
  })
  
  
  output$dataSummaryhc <- renderPrint({
    req(datahc())
    summary(datahc())
  })  
  
  # Create reactive expressions for each method that trigger only when the corresponding button is clicked
  average_hc_reactive <- eventReactive(input$runavehc, {
    req(datahc(), input$independentVarhc)
    # Early return if conditions are not met
    if (length(input$independentVarhc) == 0) {
      output$modelOutputhc <- renderPrint({ "Please select the second variable." })
      return()
    }
    data_hc <- datahc() %>%
      dplyr::select(input$independentVarhc) %>%
      na.omit()
    if (nrow(data_hc) < 10) {
      output$modelOutputhc <- renderPrint({ "Dataset is too small after removing NA values." })
      return()
    }
    # Partition the data
    hc_average <- hclust(dist(scale(data_hc)), method = "average")
    return(hc_average)
  })
  
  centroid_hc_reactive <- eventReactive(input$runcenhc, {  # Please make sure you have a separate button ID for centroid linkage
    req(datahc(), input$independentVarhc)
    # Early return if conditions are not met
    if (length(input$independentVarhc) == 0) {
      output$modelOutputhc <- renderPrint({ "Please select the second variable." })
      return()
    }
    data_hc <- datahc() %>%
      dplyr::select(input$independentVarhc) %>%
      na.omit()
    if (nrow(data_hc) < 10) {
      output$modelOutputhc <- renderPrint({ "Dataset is too small after removing NA values." })
      return()
    }
    hc_centroid <- hclust(dist(scale(data_hc)), method = "centroid")
    return(hc_centroid)
  })
  
  
  #Average Dendogram
  output$averageDendrogram <- renderPlotly({
    hc_average <- average_hc_reactive()
    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
    hc_average <- hclust(dist(datahc()), method = "average")
    # Directly cut the dendrogram
    clusters <- cutree(hc_average, k = input$numCentershc)
    # Plot the dendrogram
    ggdendrogram(hc_average, rotate = FALSE) + 
      labs(title = "Average Linkage with Scaled Features") +
      geom_hline(yintercept = which.max(table(clusters)), linetype = "dashed")
  })
  
  output$silhouettePlotHCave <- renderPlotly({
    hc_average <- average_hc_reactive()
    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
    # Compute hierarchical clustering with average linkage
    hc_average <- hclust(dist(datahc()), method = "average")
    # Cut the dendrogram to create cluster assignments
    clusters <- cutree(hc_average, k = input$numCentershc)
    # Compute the silhouette information
    silhouette_info <- silhouette(clusters, dist(datahc()))
    # Visualize the silhouette plot
    fviz_silhouette(silhouette_info) + 
      labs(title = "Silhouette Plot for Hierarchical Clustering (Average Linkage)")
  })
  
  #Centroid Dendogram
  output$centroidDendrogram <- renderPlotly({
    hc_centroid <- centroid_hc_reactive()
    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
    hc_centroid <- hclust(dist(datahc()), method = "centroid")
    # Directly cut the dendrogram
    clusters <- cutree(hc_centroid, k = input$numCentershc)
    # Plot the dendrogram
    ggdendrogram(hc_centroid, rotate = FALSE) + 
      labs(title = "Centroid Linkage with Scaled Features") +
      geom_hline(yintercept = which.max(table(clusters)), linetype = "dashed")
  })
  
  output$silhouettePlotHCcen <- renderPlotly({
    hc_centroid <- centroid_hc_reactive()
    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
    # Compute hierarchical clustering with centroid linkage
    hc_centroid <- hclust(dist(datahc()), method = "centroid")
    # Cut the dendrogram to create cluster assignments
    clusters <- cutree(hc_centroid, k = input$numCentershc)
    # Compute the silhouette information
    silhouette_info <- silhouette(clusters, dist(datahc()))
    # Visualize the silhouette plot
    fviz_silhouette(silhouette_info) + 
      labs(title = "Silhouette Plot for Hierarchical Clustering (Centroid Linkage)")
  })
  
  #ward.D2  Dendogram
  wardd2_hc_reactive <- eventReactive(input$runwddhc, {  # Please make sure you have a separate button ID for ward.D2 linkage
    req(datahc(), input$independentVarhc)
    # Early return if conditions are not met
    if (length(input$independentVarhc) == 0) {
      output$modelOutputhc <- renderPrint({ "Please select the second variable." })
      return()
    }
    data_hc <- datahc() %>%
      dplyr::select(input$independentVarhc) %>%
      na.omit()
    if (nrow(data_hc) < 10) {
      output$modelOutputhc <- renderPrint({ "Dataset is too small after removing NA values." })
      return()
    }
    hc_wardd2 <- hclust(dist(scale(data_hc)), method = "ward.D2")
    return(hc_wardd2)
  })
  
  
  output$wdd2Dendrogram <- renderPlotly({
    hc_wardd2 <- wardd2_hc_reactive()
    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
    hc_wardd2 <- hclust(dist(datahc()), method = "ward.D2")
    # Directly cut the dendrogram
    clusters <- cutree(hc_wardd2, k = input$numCentershc)
    # Plot the dendrogram
    ggdendrogram(hc_wardd2, rotate = FALSE) + 
      labs(title = "Ward D2 Linkage with Scaled Features") +
      geom_hline(yintercept = which.max(table(clusters)), linetype = "dashed")
  })
  
  output$silhouettePlotHCwdd2 <- renderPlotly({
    hc_wardd2 <- wardd2_hc_reactive()
    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
    # Compute hierarchical clustering with ward.D2 linkage
    hc_wardd2 <- hclust(dist(datahc()), method = "ward.D2")
    # Cut the dendrogram to create cluster assignments
    clusters <- cutree(hc_wardd2, k = input$numCentershc)
    # Compute the silhouette information
    silhouette_info <- silhouette(clusters, dist(datahc()))
    # Visualize the silhouette plot
    fviz_silhouette(silhouette_info) + 
      labs(title = "Silhouette Plot for Hierarchical Clustering (Ward D2 Linkage)")
  })
  
  #WPGMA  Dendogram
  mcqu_hc_reactive <- eventReactive(input$runmchc, {  # Please make sure you have a separate button ID for mcquitty linkage
    req(datahc(), input$independentVarhc)
    # Early return if conditions are not met
    if (length(input$independentVarhc) == 0) {
      output$modelOutputhc <- renderPrint({ "Please select the second variable." })
      return()
    }
    data_hc <- datahc() %>%
      dplyr::select(input$independentVarhc) %>%
      na.omit()
    if (nrow(data_hc) < 10) {
      output$modelOutputhc <- renderPrint({ "Dataset is too small after removing NA values." })
      return()
    }
    hc_mcqu <- hclust(dist(scale(data_hc)), method = "mcquitty")
    return(hc_mcqu)
  })
  
  
  output$mcquDendrogram <- renderPlotly({
    hc_mcqu <- mcqu_hc_reactive()
    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
    hc_mcqu <- hclust(dist(datahc()), method = "mcquitty")
    # Directly cut the dendrogram
    clusters <- cutree(hc_mcqu, k = input$numCentershc)
    # Plot the dendrogram
    ggdendrogram(hc_mcqu, rotate = FALSE) + 
      labs(title = "Mcquity Linkage with Scaled Features") +
      geom_hline(yintercept = which.max(table(clusters)), linetype = "dashed")
  })
  
  output$silhouettePlotHCmc <- renderPlotly({
    hc_mcqu <- mcqu_hc_reactive()
    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
    # Compute hierarchical clustering with mcquitty linkage
    hc_mcqu <- hclust(dist(datahc()), method = "mcquitty")
    # Cut the dendrogram to create cluster assignments
    clusters <- cutree(hc_mcqu, k = input$numCentershc)
    # Compute the silhouette information
    silhouette_info <- silhouette(clusters, dist(datahc()))
    # Visualize the silhouette plot
    fviz_silhouette(silhouette_info) + 
      labs(title = "Silhouette Plot for Hierarchical Clustering (Mcquity Linkage)")
  })
  
  ###Density-based spatial clustering of applications - DBSCAN
  datadbscan <- reactiveVal(NULL)
  dbscan_model_reactive <- reactiveVal()
  # Load and clean data
  observeEvent(input$loaddbscan, {
    req(input$dbscaninput)
    file <- input$dbscaninput
    if (!is.null(file)) {
      # Reading and cleaning data
      data_df <- read_data(file$datapath)
      data_df <- clean_column_names(data_df)
      
      # Setting the reactive value
      datadbscan(data_df)
      
      # Updating UI elements
      updateSelectInput(session, "independentVardbscan", choices = colnames(data_df))
    }
  })
  
  
  output$dataSummarydbscan <- renderPrint({
    req(datadbscan())
    summary(datadbscan())
  }) 
  
  #kNN Neighboring
  kNN_dbscan_reactive <- eventReactive(input$rundbscandist, {  # Please make sure you have a separate button ID for mcquitty linkage
    req(datadbscan(), input$independentVardbscan)
    # Early return if conditions are not met
    if (length(input$independentVardbscan) == 0) {
      output$modelOutputdbscan <- renderPrint({ "Please select the second variable." })
      return()
    }
    data_dbscan <- datadbscan() %>%
      dplyr::select(input$independentVardbscan) %>%
      na.omit()
    if (nrow(data_dbscan) < 10) {
      output$modelOutputdbscan <- renderPrint({ "Dataset is too small after removing NA values." })
      return()
    }
    dbscan_model <- scale(data_dbscan)
    return(dbscan_model)
  })
  
  output$rundbscandist <- renderPlot({
    dbscan_model <- kNN_dbscan_reactive()
    req(dbscan_model)
    
    # Assuming dbscan_model is scaled appropriately
    dists <- kNNdist(dbscan_model, k = 10)
    plot(dists, type='l', main="kNN distance")
    abline(h = 0.5, col = 'red', lty = 2)  # Example line, adjust based on elbow
    
    # Heuristic to find the elbow point
    diff_dists <- diff(dists)
    optimal_eps <- which.max(diff_dists)
    
    # Add a vertical line at the optimal eps value
    abline(v = optimal_eps, col = 'blue', lwd = 2)
    
    # Annotate the optimal eps value on the plot
    text(x = optimal_eps, y = dists[optimal_eps], labels = paste("Eps:", round(dists[optimal_eps], 2)), pos = 4, col = 'blue')
  })
  
  
  observeEvent(input$rundbscan, {
    req(datadbscan(), input$independentVardbscan)
    
    withProgress(message = 'Model is being trained...', value = 0, {
      incProgress(0.1)
      data_dbscan <- datadbscan() %>%
        dplyr::select(input$independentVardbscan) %>%
        na.omit()
      
      # Check for variable selection and data size
      if (length(input$independentVardbscan) == 0 || nrow(data_dbscan) < 10) {
        output$modelOutputdbscan <- renderPrint({ "Please check your variable selection and ensure the dataset is not too small." })
        incProgress(1.0)
        return()
      }
      incProgress(0.3)
      # Fit the DBSCAN model
      dbscan_model <- dbscan(data_dbscan, eps = input$numepsdbscan)
      
      # Combine data with cluster labels
      clustering_results <- cbind(data_dbscan, cluster = dbscan_model$cluster)
      incProgress(0.7)
      # Save the clustering results in a reactive value
      dbscan_model_reactive(clustering_results)
      
      # Model summary
      output$rundbscan <- renderPrint({ print(dbscan_model) })
      
      incProgress(1.0)
    })
  })
  
  
  # Use the clustering results for plotting
  output$clusteringPlotdbscan <- renderPlotly({
    clustering_results <- dbscan_model_reactive()
    
    if (is.null(clustering_results) || nrow(clustering_results) == 0) {
      print("No data available for plotting.")
      return()
    }
    
    selected_columns <- input$independentVardbscan
    
    if (!"cluster" %in% names(clustering_results) || any(is.na(clustering_results$cluster))) {
      print("Cluster assignments are missing or contain NA values.")
      return()
    }
    
    data_for_plot <- clustering_results[, selected_columns]
    
    # Create a pseudo clustering object for fviz_cluster
    pseudo_cluster_obj <- list(
      data = data_for_plot,
      cluster = clustering_results$cluster
    )
    
    # Visualization using fviz_cluster
    fviz_cluster(pseudo_cluster_obj, geom = "point", stand = FALSE)
    
  })
  
  output$silhouettePlotdbscan <- renderPlotly({
    clustering_results <- dbscan_model_reactive()
    
    if (is.null(clustering_results) || nrow(clustering_results) == 0) {
      print("No data available for silhouette analysis.")
      return()
    }
    
    selected_columns <- input$independentVardbscan
    
    if (!"cluster" %in% names(clustering_results) || any(is.na(clustering_results$cluster))) {
      print("Cluster assignments are missing or contain NA values.")
      return()
    }
    
    data_for_plot <- clustering_results[, selected_columns]
    clusters <- clustering_results$cluster
    
    # Compute distance matrix if not already computed
    dist_matrix <- dist(data_for_plot)
    
    # Compute silhouette values
    sil_values <- silhouette(clusters, dist_matrix)
    
    # Visualization using fviz_silhouette
    fviz_silhouette(sil_values)
  })
  
  ###Associated Rule Learning
  dataarl <- reactiveVal(NULL)  # Will hold the transactions object
  buttonClicked <- reactiveVal(FALSE)
  # Reactive value for storing the raw data
  rawData <- reactiveVal(NULL)
  
  observeEvent(input$loadarl, {
    req(input$arlinput)
    # After reading the file
    if (tools::file_ext(input$arlinput$datapath) == "csv") {
      df <- read.csv(input$arlinput$datapath, stringsAsFactors = FALSE)
    } else if (tools::file_ext(input$arlinput$datapath) == "xlsx") {
      df <- readxl::read_excel(input$arlinput$datapath)
    }
    # Make sure df is a data frame and then store it
    rawData(df)  # Assuming rawData is meant to store the raw data frame
    
    # Update UI for column selection
    updateSelectInput(session, "targetarl", "Select ID Column", choices = colnames(df))
    updateSelectInput(session, "itemsColumn", "Select Transaction Column", choices = colnames(df))
    
    buttonClicked(FALSE)  # Reset the button click status
  })
  
  # Create a separate event for when the user confirms the column selection and clicks another action button to run ARL
  observeEvent(input$runarl, {
    req(rawData(), input$targetarl, input$itemsColumn)
    print(str(dataarl()))  # Debug: Check the structure of dataarl()
    df <- rawData()
    # Directly read the uploaded file again for this action, for debugging
    if (tools::file_ext(input$arlinput$datapath) == "csv") {
      df <- read.csv(input$arlinput$datapath, stringsAsFactors = FALSE)
    } else if (tools::file_ext(input$arlinput$datapath) == "xlsx") {
      df <- readxl::read_excel(input$arlinput$datapath)
    } else {
      stop("Unsupported file type")
    }
    
    # Now df is guaranteed to be a data frame here
    selected_data <- df %>%
      dplyr::select(dplyr::all_of(input$targetarl), dplyr::all_of(input$itemsColumn)) %>%
      dplyr::arrange(dplyr::all_of(input$targetarl))
    
    # Assuming each row is a transaction with a single item
    # Create a unique identifier for each transaction
    selected_data <- selected_data %>%
      group_by(!!sym(input$targetarl)) %>%
      summarise(Items = paste(!!sym(input$itemsColumn), collapse = ", ")) %>%
      ungroup()
    
    # Write the preprocessed data to a temporary file for read.transactions
    temp_file <- tempfile(fileext = ".csv")
    write.table(selected_data, temp_file, row.names = FALSE, quote = FALSE, sep = ",")
    
    # Now read the transactions from the temporary file
    trans <- read.transactions(temp_file, format = "basket", sep = ",", rm.duplicates = TRUE)
    
    # Update the reactive value holding the transactions
    dataarl(trans)
    
    buttonClicked(TRUE)
    # Cleanup: Remove the temporary file
    unlink(temp_file)
  })
  
  
  # Assuming 'data' is your data frame and 'itemDescription' is your items column
  preprocess_data <- function(data, itemsColumn) {
    req(rawData(), dataarl(), input$targetarl, input$itemsColumn)
    df <- rawData()
    # Ensure the column is a character to avoid issues with factors
    data[[itemsColumn]] <- as.character(data[[itemsColumn]])
    
    # Remove unwanted characters such as new line characters and extra spaces
    data[[itemsColumn]] <- gsub("\n", "", data[[itemsColumn]])
    data[[itemsColumn]] <- gsub("\"", "", data[[itemsColumn]])
    data[[itemsColumn]] <- trimws(data[[itemsColumn]]) # Trim white spaces
    
    return(data)
  }
  
  # Render Item Frequency Plot
  createItemFreqPlot <- function(transactions, topN = 35) {
    freq <- itemFrequency(transactions, type = "absolute")
    freq_df <- data.frame(items = names(freq), frequency = freq)
    
    freq_df <- freq_df[order(-freq_df$frequency), ][1:topN, ]
    
    # Generate a palette with as many colors as bars
    colors <- scales::hue_pal()(topN)
    
    ggplot(freq_df, aes(x = reorder(items, -frequency), y = frequency, fill = items)) +
      geom_bar(stat = "identity") +
      scale_fill_manual(values = colors) +
      xlab("Items") +
      ylab("Frequency") +
      coord_flip() +
      theme(legend.position = "none")  # Optionally hide the legend
  }
  
  
  # Use preprocess_data in the eventReactive for plotData
  plotData <- eventReactive(input$runarl, {
    buttonClicked(TRUE)  # Set to true when button is clicked
    req(rawData(), dataarl(), input$targetarl, input$itemsColumn)
    df <- rawData()
    
    # Debug: Print the structure of the data
    print(str(dataarl()))
    cleaned_data <- preprocess_data(df, input$itemsColumn)
    
    # Assuming that items are separated by a comma, adjust if necessary
    items_list <- strsplit(as.character(cleaned_data[[input$itemsColumn]]), split = ",")
    
    # Convert the list of items into transactions
    transactions <- as(items_list, "transactions")
    
    # Create the item frequency plot
    createItemFreqPlot(transactions, topN = 20)
  }, ignoreNULL = FALSE)
  
  
  # Render plot using Plotly
  output$itemFreqPlot <- renderPlotly({
    req(buttonClicked(), plotData())  # Check if button has been clicked
    ggplotly(plotData())
  })
  
  #Appriori Function
  arl_model_reactive <- eventReactive(input$runarl, {
    req(rawData(), input$targetarl, input$itemsColumn)
    df <- rawData()
    
    # Preprocess and clean the data
    cleaned_data <- preprocess_data(df, input$itemsColumn)
    
    # Aggregate items by transaction ID into a single string per transaction
    aggregated_data <- cleaned_data %>%
      group_by(!!sym(input$targetarl)) %>%
      summarise(Items = paste(!!sym(input$itemsColumn), collapse = ", ")) %>%
      ungroup()
    
    # Convert the aggregated item strings into a list of transactions
    transactions_list <- split(aggregated_data$Items, aggregated_data[[input$targetarl]])
    transactions_list <- lapply(transactions_list, function(items) {
      unlist(strsplit(items, ",\\s*"))
    })
    
    # Create a transactions object
    transactions <- arules::transactions(transactions_list)
    
    # Run the Apriori algorithm
    arl_rules <- apriori(transactions, parameter = list(supp = 0.001, conf = 0.37))
    
    # Return the rules so they're stored in arl_model_reactive
    return(arl_rules)
  }, ignoreNULL = FALSE)
  
  # Reactive expression for sorted rules
  sorted_rules_reactive <- reactive({
    # Make sure to call arl_model_reactive() to get its value
    req(arl_model_reactive())
    
    # Sort the rules by lift
    sorted_rules <- sort(arl_model_reactive(), by = "lift")
    
    # Return the sorted rules so they can be used in the output
    return(sorted_rules)
  })
  
  # Render the sorted rules
  output$sortedARLOutput <- renderPrint({
    req(sorted_rules_reactive())
    
    # Use inspect to print the sorted rules
    inspect(sorted_rules_reactive())
  })

}

shinyApp(ui, server)