const hyprland = await Service.import("hyprland")
const notifications = await Service.import("notifications")
const mpris = await Service.import("mpris")
const audio = await Service.import("audio")
const battery = await Service.import("battery")
const systemtray = await Service.import("systemtray")
import { getIconName } from "./utils.js"

const date = Variable("", {
  poll: [1000, 'date "+%H:%M:%S %b %e."'],
})

function Clients() {
  const activeId = hyprland.active.client.bind("address")
  let clients = hyprland.clients.filter(a => a.workspace.id == hyprland.active.workspace.id).map(({ address, title }) =>
    Widget.Button({
      child: Widget.Box({
        children: [
          Widget.Icon({
            vexpand: false,
            size: 16,
            className: "app-icon",
            icon: getIconName(hyprland.clients.find(c => c.address === address))
          }),
          Widget.Label(`${title}`)
        ],
      }),
      class_name: activeId.as(i => `${i === address ? "client-title focused" : "client-title"}`),
    }))
  return Widget.Box({
    class_name: "clients",
    children: clients,
  })
}

function Workspaces() {
  const activeId = hyprland.active.workspace.bind("id")
  const workspaces = hyprland.bind("workspaces").as(ws => {
    ws.sort((a, b) => a.id - b.id)
    return ws.map(({ id, monitorID }) =>
      Widget.Button({
        attribute: monitorID,
        label: `${id}`,
        onClicked: () => dispatch(i),
        class_name: activeId.as(i => `${i === id ? "focused" : ""}`),
      })
    )
  })

  return Widget.Box({
    children: workspaces,
    setup: self => self.hook(hyprland, () => self.children.forEach(btn => {
      btn.visible = hyprland.active.monitor.id === btn.attribute
    })),
  })
}




function Clock() {
  return Widget.Label({
    class_name: "clock",
    label: date.bind(),
  })
}


// we don't need dunst or any other notification daemon
// because the Notifications module is a notification daemon itself
function Notification() {
  const popups = notifications.bind("popups")
  return Widget.Box({
    class_name: "notification",
    visible: popups.as(p => p.length > 0),
    children: [
      Widget.Icon({
        icon: "preferences-system-notifications-symbolic",
      }),
      Widget.Label({
        label: popups.as(p => p[0]?.summary || ""),
      }),
    ],
  })
}

function SysTray() {
  const items = systemtray.bind("items")
  .as(items => items.map(item => Widget.Button({
    child: Widget.Icon({
      icon: item.bind("icon"),
      css: "margin-left: 0.6em;margin-right: 0.6em;"
    }),
    on_primary_click: (_, event) => item.activate(event),
    on_secondary_click: (_, event) => item.openMenu(event),
    tooltip_markup: item.bind("tooltip_markup"),
    css: "margin-left: 0.4em;",
  })))

  return Widget.Box({
    children: items,
  })
}


// layout of the bar
function Left() {
  return Widget.Box({
    spacing: 8,
    children: [
      Clients(),
      // ClientTitle(),
    ],
  })
}

function Center() {
  return Widget.Box({
    spacing: 8,
    children: [
      Workspaces(),
      Notification(),
    ],
  })
}

function Right() {
  return Widget.Box({
    hpack: "end",
    spacing: 8,
    children: [
      SysTray(),
      Clock(),
    ],
  })
}

function Bar(monitor = 0) {
  return Widget.Window({
    name: `bar-${monitor}`, // name has to be unique
    class_name: "bar",
    monitor,
    anchor: ["top", "left", "right"],
    exclusivity: "exclusive",
    child: Widget.CenterBox({
      css: "margin-bottom: 0.2em;",
      start_widget: Left(),
      center_widget: Center(),
      end_widget: Right(),
    }),
  })
}

App.config({
  style: "./style.css",
  windows: [
    Bar(),

    // you can call it, for each monitor
    // Bar(0),
    // Bar(1)
  ],
})

export { }