library(dplyr)

# Konversi hasil validasi
val_result <- as.data.frame(data_val)

# Ambil ID yang gagal atau NA pada status_perkawinan
invalid_ids_status <- val_result %>%
  filter(name == "status_perkawinan" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keselurhan
valid_ids_status <- val_result %>%
  filter(is.na(value)==F |value == TRUE) %>%
  pull(id) %>%
  unique()

# Fungsi modus
get_modus <- function(x) {
  ux <- unique(x[!is.na(x)])
  ux[which.max(tabulate(match(x, ux)))]
}

# Imputasi berdasarkan tingkat_pendidikan (jika tidak ada, fallback ke jenis_pekerjaan)
for (id in invalid_ids_status) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  pendidikan <- baris$tingkat_pendidikan
  fallback <- baris$jenis_pekerjaan
  modus <- NA
  
  if (!is.na(pendidikan)) {
    valid_status <- dataset %>%
      filter(
        id %in% valid_ids_status,
        tingkat_pendidikan == pendidikan,
        !is.na(status_perkawinan)
      ) %>%
      pull(status_perkawinan)
    
    modus <- get_modus(valid_status)
  }
  
  # Fallback ke jenis_pekerjaan jika modus masih NA
  if (is.na(modus) && !is.na(fallback)) {
    valid_status_fallback <- dataset %>%
      filter(
        id %in% valid_ids_status,
        jenis_pekerjaan == fallback,
        !is.na(status_perkawinan)
      ) %>%
      pull(status_perkawinan)
    
    modus <- get_modus(valid_status_fallback)
  }

  # Imputasi jika modus berhasil ditemukan
  if (!is.na(modus)) {
    dataset$status_perkawinan[dataset$id == id] <- modus
  }
}

# Ambil ID yang gagal atau NA pada tingkat_pendidikan
invalid_ids_pendidikan <- val_result %>%
  filter(name == "tingkat_pendidikan" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_pendidikan <- val_result %>%
  filter(is.na(value)==F |value == TRUE) %>%
  pull(id) %>%
  unique()

# Fungsi modus
get_modus <- function(x) {
  ux <- unique(x[!is.na(x)])
  ux[which.max(tabulate(match(x, ux)))]
}

# Imputasi berdasarkan jenis_pekerjaan (fallback ke status_perkawinan)
for (id in invalid_ids_pendidikan) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  pekerjaan <- baris$jenis_pekerjaan
  fallback <- baris$status_perkawinan
  modus <- NA

  if (!is.na(pekerjaan)) {
    valid_pendidikan <- dataset %>%
      filter(
        id %in% valid_ids_pendidikan,
        jenis_pekerjaan == pekerjaan,
        !is.na(tingkat_pendidikan)
      ) %>%
      pull(tingkat_pendidikan)
    
    modus <- get_modus(valid_pendidikan)
  }

  # Fallback ke status_perkawinan jika modus masih NA
  if (is.na(modus) && !is.na(fallback)) {
    valid_pendidikan_fallback <- dataset %>%
      filter(
        id %in% valid_ids_pendidikan,
        status_perkawinan == fallback,
        !is.na(tingkat_pendidikan)
      ) %>%
      pull(tingkat_pendidikan)
    
    modus <- get_modus(valid_pendidikan_fallback)
  }

  # Imputasi jika modus berhasil ditemukan
  if (!is.na(modus)) {
    dataset$tingkat_pendidikan[dataset$id == id] <- modus
  }
}

# Ambil ID yang gagal atau NA pada jenis_pekerjaan
invalid_ids_pekerjaan <- val_result %>%
  filter(name == "jenis_pekerjaan" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_pekerjaan <- val_result %>%
  filter((is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Fungsi modus
get_modus <- function(x) {
  ux <- unique(x[!is.na(x)])
  if (length(ux) == 0) return(NA)
  ux[which.max(tabulate(match(x, ux)))]
}

# Imputasi jenis_pekerjaan berdasarkan tingkat_pendidikan, fallback ke status_perkawinan
for (id in invalid_ids_pekerjaan) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  pendidikan <- baris$tingkat_pendidikan
  fallback <- baris$status_perkawinan
  modus <- NA
  
  # Gunakan tingkat_pendidikan sebagai kriteria utama
  if (!is.na(pendidikan)) {
    valid_pekerjaan <- dataset %>%
      filter(
        id %in% valid_ids_pekerjaan,
        tingkat_pendidikan == pendidikan,
        !is.na(jenis_pekerjaan)
      ) %>%
      pull(jenis_pekerjaan)
    
    modus <- get_modus(valid_pekerjaan)
  }
  
  # Fallback ke status_perkawinan jika modus masih NA
  if (is.na(modus) && !is.na(fallback)) {
    valid_pekerjaan_fallback <- dataset %>%
      filter(
        id %in% valid_ids_pekerjaan,
        status_perkawinan == fallback,
        !is.na(jenis_pekerjaan)
      ) %>%
      pull(jenis_pekerjaan)
    
    modus <- get_modus(valid_pekerjaan_fallback)
  }
  
  # Imputasi jika modus ditemukan
  if (!is.na(modus)) {
    dataset$jenis_pekerjaan[dataset$id == id] <- modus
  }
}

# Ambil ID yang gagal atau NA pada kepemilikan_rumah
invalid_ids_rumah <- val_result %>%
  filter(name == "kepemilikan_rumah" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_rumah <- val_result %>%
  filter((is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Fungsi modus (tetap sama)
get_modus <- function(x) {
  ux <- unique(x[!is.na(x)])
  if (length(ux) == 0) return(NA)
  ux[which.max(tabulate(match(x, ux)))]
}

# Imputasi kepemilikan_rumah berdasarkan jenis_pekerjaan, fallback ke wilayah
for (id in invalid_ids_rumah) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  pekerjaan <- baris$jenis_pekerjaan
  fallback <- baris$wilayah
  modus <- NA
  
  # Gunakan jenis_pekerjaan sebagai kriteria utama
  if (!is.na(pekerjaan)) {
    valid_rumah <- dataset %>%
      filter(
        id %in% valid_ids_rumah,
        jenis_pekerjaan == pekerjaan,
        !is.na(kepemilikan_rumah)
      ) %>%
      pull(kepemilikan_rumah)
    
    modus <- get_modus(valid_rumah)
  }
  
  # Fallback ke wilayah jika modus masih NA
  if (is.na(modus) && !is.na(fallback)) {
    valid_rumah_fallback <- dataset %>%
      filter(
        id %in% valid_ids_rumah,
        wilayah == fallback,
        !is.na(kepemilikan_rumah)
      ) %>%
      pull(kepemilikan_rumah)
    
    modus <- get_modus(valid_rumah_fallback)
  }
  
  # Imputasi jika modus ditemukan
  if (!is.na(modus)) {
    dataset$kepemilikan_rumah[dataset$id == id] <- modus
  }
}

# Ambil ID yang gagal atau NA pada akses_internet
invalid_ids_internet <- val_result %>%
  filter(name == "akses_internet" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_internet <- val_result %>%
  filter((is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Imputasi akses_internet berdasarkan wilayah, fallback ke tingkat_pendidikan
for (id in invalid_ids_internet) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  wilayah <- baris$wilayah
  fallback <- baris$tingkat_pendidikan
  modus <- NA
  
  # Gunakan wilayah sebagai kriteria utama
  if (!is.na(wilayah)) {
    valid_internet <- dataset %>%
      filter(
        id %in% valid_ids_internet,
        wilayah == wilayah,
        !is.na(akses_internet)
      ) %>%
      pull(akses_internet)
    
    modus <- get_modus(valid_internet)
  }
  
  # Fallback ke tingkat_pendidikan jika modus masih NA
  if (is.na(modus) && !is.na(fallback)) {
    valid_internet_fallback <- dataset %>%
      filter(
        id %in% valid_ids_internet,
        tingkat_pendidikan == fallback,
        !is.na(akses_internet)
      ) %>%
      pull(akses_internet)
    
    modus <- get_modus(valid_internet_fallback)
  }
  
  # Imputasi jika modus ditemukan
  if (!is.na(modus)) {
    dataset$akses_internet[dataset$id == id] <- modus
  }
}

# Ambil ID yang gagal atau NA pada jenis_kelamin
invalid_ids_kelamin <- val_result %>%
  filter(name == "jenis_kelamin" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_kelamin <- val_result %>%
  filter((is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Imputasi jenis_kelamin berdasarkan jenis_pekerjaan, fallback ke status_perkawinan
for (id in invalid_ids_kelamin) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  pekerjaan <- baris$jenis_pekerjaan
  fallback <- baris$status_perkawinan
  modus <- NA
  
  # Gunakan jenis_pekerjaan sebagai kriteria utama
  if (!is.na(pekerjaan)) {
    valid_kelamin <- dataset %>%
      filter(
        id %in% valid_ids_kelamin,
        jenis_pekerjaan == pekerjaan,
        !is.na(jenis_kelamin)
      ) %>%
      pull(jenis_kelamin)
    
    modus <- get_modus(valid_kelamin)
  }
  
  # Fallback ke status_perkawinan jika modus masih NA
  if (is.na(modus) && !is.na(fallback)) {
    valid_kelamin_fallback <- dataset %>%
      filter(
        id %in% valid_ids_kelamin,
        status_perkawinan == fallback,
        !is.na(jenis_kelamin)
      ) %>%
      pull(jenis_kelamin)
    
    modus <- get_modus(valid_kelamin_fallback)
  }
  
  # Imputasi jika modus ditemukan
  if (!is.na(modus)) {
    dataset$jenis_kelamin[dataset$id == id] <- modus
  }
}

# Ambil ID yang gagal atau NA pada wilayah
invalid_ids_wilayah <- val_result %>%
  filter(name == "wilayah" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_wilayah <- val_result %>%
  filter((is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Imputasi wilayah berdasarkan akses_internet, fallback ke jenis_pekerjaan
for (id in invalid_ids_wilayah) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  akses_internet <- baris$akses_internet
  fallback <- baris$jenis_pekerjaan
  modus <- NA
  
  # Gunakan akses_internet sebagai kriteria utama
  if (!is.na(akses_internet)) {
    valid_wilayah <- dataset %>%
      filter(
        id %in% valid_ids_wilayah,
        akses_internet == akses_internet,
        !is.na(wilayah)
      ) %>%
      pull(wilayah)
    
    modus <- get_modus(valid_wilayah)
  }
  
  # Fallback ke jenis_pekerjaan jika modus masih NA
  if (is.na(modus) && !is.na(fallback)) {
    valid_wilayah_fallback <- dataset %>%
      filter(
        id %in% valid_ids_wilayah,
        jenis_pekerjaan == fallback,
        !is.na(wilayah)
      ) %>%
      pull(wilayah)
    
    modus <- get_modus(valid_wilayah_fallback)
  }
  
  # Imputasi jika modus ditemukan
  if (!is.na(modus)) {
    dataset$wilayah[dataset$id == id] <- modus
  }
}

# Ambil ID yang gagal atau NA pada pendapatan_tahunan
invalid_ids_pendapatan <- val_result %>%
  filter(name == "pendapatan_tahunan" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_pendapatan <- val_result %>%
  filter((is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Fungsi untuk menghitung rata-rata dengan 0 digit di belakang koma
get_mean <- function(x) {
  mean(x, na.rm = TRUE)
}

# Imputasi pendapatan_tahunan berdasarkan jenis_pekerjaan, fallback ke tingkat_pendidikan
for (id in invalid_ids_pendapatan) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  pekerjaan <- baris$jenis_pekerjaan
  fallback <- baris$tingkat_pendidikan
  imputasi_value <- NA
  
  # Gunakan jenis_pekerjaan sebagai kriteria utama
  if (!is.na(pekerjaan)) {
    valid_pendapatan <- dataset %>%
      filter(
        id %in% valid_ids_pendapatan,
        jenis_pekerjaan == pekerjaan,
        !is.na(pendapatan_tahunan)
      ) %>%
      pull(pendapatan_tahunan)
    
    imputasi_value <- get_mean(valid_pendapatan)
  }
  
  # Fallback ke tingkat_pendidikan jika rata-rata masih NA
  if (is.na(imputasi_value) && !is.na(fallback)) {
    valid_pendapatan_fallback <- dataset %>%
      filter(
        id %in% valid_ids_pendapatan,
        tingkat_pendidikan == fallback,
        !is.na(pendapatan_tahunan)
      ) %>%
      pull(pendapatan_tahunan)
    
    imputasi_value <- get_mean(valid_pendapatan_fallback)
  }
  
  # Imputasi jika rata-rata berhasil ditemukan
  if (!is.na(imputasi_value)) {
    dataset$pendapatan_tahunan[dataset$id == id] <- round(imputasi_value, 0)
  }
}

# Ambil ID yang gagal atau NA pada pengeluaran_bulanan
invalid_ids_pengeluaran <- val_result %>%
  filter(name == "pengeluaran_bulanan" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_pengeluaran <- val_result %>%
  filter((is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Fungsi untuk menghitung rata-rata dengan 0 digit di belakang koma
get_mean <- function(x) {
  mean(x, na.rm = TRUE)
}

# Imputasi pengeluaran_bulanan berdasarkan jenis_pekerjaan, fallback ke kepemilikan_rumah
for (id in invalid_ids_pengeluaran) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  pekerjaan <- baris$jenis_pekerjaan
  kepemilikan <- baris$kepemilikan_rumah
  imputasi_value <- NA
  
  # Gunakan jenis_pekerjaan sebagai kriteria utama
  if (!is.na(pekerjaan)) {
    valid_pengeluaran <- dataset %>%
      filter(
        id %in% valid_ids_pengeluaran,
        jenis_pekerjaan == pekerjaan,
        !is.na(pengeluaran_bulanan)
      ) %>%
      pull(pengeluaran_bulanan)
    
    imputasi_value <- get_mean(valid_pengeluaran)
  }
  
  # Fallback ke kepemilikan_rumah jika rata-rata masih NA
  if (is.na(imputasi_value) && !is.na(kepemilikan)) {
    valid_pengeluaran_fallback <- dataset %>%
      filter(
        id %in% valid_ids_pengeluaran,
        kepemilikan_rumah == kepemilikan,
        !is.na(pengeluaran_bulanan)
      ) %>%
      pull(pengeluaran_bulanan)
    
    imputasi_value <- get_mean(valid_pengeluaran_fallback)
  }
  
  # Imputasi jika rata-rata berhasil ditemukan
  if (!is.na(imputasi_value)) {
    dataset$pengeluaran_bulanan[dataset$id == id] <- round(imputasi_value, 0)
  }
}

# Ambil ID yang gagal atau NA pada jumlah_anggota_keluarga
invalid_ids_anggota_keluarga <- val_result %>%
  filter(name == "jumlah_anggota_keluarga" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_anggota_keluarga <- val_result %>%
  filter( (is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Fungsi untuk menghitung rata-rata dengan 0 digit di belakang koma
get_mean <- function(x) {
  mean(x, na.rm = TRUE)
}

# Imputasi jumlah_anggota_keluarga berdasarkan status_perkawinan, fallback ke kepemilikan_rumah
for (id in invalid_ids_anggota_keluarga) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  status_perkawinan <- baris$status_perkawinan
  kepemilikan <- baris$kepemilikan_rumah
  imputasi_value <- NA
  
  # Gunakan status_perkawinan sebagai kriteria utama
  if (!is.na(status_perkawinan)) {
    valid_anggota <- dataset %>%
      filter(
        id %in% valid_ids_anggota_keluarga,
        status_perkawinan == status_perkawinan,
        !is.na(jumlah_anggota_keluarga)
      ) %>%
      pull(jumlah_anggota_keluarga)
    
    imputasi_value <- get_mean(valid_anggota)
  }
  
  # Fallback ke kepemilikan_rumah jika rata-rata masih NA
  if (is.na(imputasi_value) && !is.na(kepemilikan)) {
    valid_anggota_fallback <- dataset %>%
      filter(
        id %in% valid_ids_anggota_keluarga,
        kepemilikan_rumah == kepemilikan,
        !is.na(jumlah_anggota_keluarga)
      ) %>%
      pull(jumlah_anggota_keluarga)
    
    imputasi_value <- get_mean(valid_anggota_fallback)
  }
  
  # Imputasi jika rata-rata berhasil ditemukan
  if (!is.na(imputasi_value)) {
    dataset$jumlah_anggota_keluarga[dataset$id == id] <- round(imputasi_value, 0)
  }
}

# Ambil ID yang gagal atau NA pada umur_kepala_rumah_tangga
invalid_ids_umur <- val_result %>%
  filter(name == "umur_kepala_rumah_tangga" & (is.na(value) | value == FALSE)) %>%
  pull(id) %>%
  unique()

# Ambil ID yang valid (tidak terlanggar atau NA) untuk keseluruhan
valid_ids_umur <- val_result %>%
  filter((is.na(value) == FALSE | value == TRUE)) %>%
  pull(id) %>%
  unique()

# Fungsi untuk menghitung rata-rata dengan 0 digit di belakang koma
get_mean <- function(x) {
  mean(x, na.rm = TRUE)
}

# Imputasi umur_kepala_rumah_tangga berdasarkan kepemilikan_rumah, fallback ke wilayah
for (id in invalid_ids_umur) {
  baris <- dataset %>% filter(id == !!id)
  
  if (nrow(baris) == 0) next
  
  kepemilikan <- baris$kepemilikan_rumah
  wilayah <- baris$wilayah
  imputasi_value <- NA
  
  # Gunakan kepemilikan_rumah sebagai kriteria utama
  if (!is.na(kepemilikan)) {
    valid_umur <- dataset %>%
      filter(
        id %in% valid_ids_umur,
        kepemilikan_rumah == kepemilikan,
        !is.na(umur_kepala_rumah_tangga)
      ) %>%
      pull(umur_kepala_rumah_tangga)
    
    imputasi_value <- get_mean(valid_umur)
  }
  
  # Fallback ke wilayah jika rata-rata masih NA
  if (is.na(imputasi_value) && !is.na(wilayah)) {
    valid_umur_fallback <- dataset %>%
      filter(
        id %in% valid_ids_umur,
        wilayah == wilayah,
        !is.na(umur_kepala_rumah_tangga)
      ) %>%
      pull(umur_kepala_rumah_tangga)
    
    imputasi_value <- get_mean(valid_umur_fallback)
  }
  
  # Imputasi jika rata-rata berhasil ditemukan
  if (!is.na(imputasi_value)) {
    dataset$umur_kepala_rumah_tangga[dataset$id == id] <- round(imputasi_value, 0)
  }
}

data_val <- confront(dataset, val, key  ="id")

summary(data_val)

plot(data_val)