local node_data = require("java-deps.java.nodeData")

local NodeKind = node_data.NodeKind

local jdtls = require("java-deps.java.jdtls")

local ExplorerNode = require("java-deps.views.explorer_node").ExplorerNode

local hieararchicalPackageNodeData = require("java-deps.java.hieararchicalPackageNodeData")

local icons = require("java-deps.views.icons")

local M = {}

M.isHierarchicalView = true

M.K_TYPE_KIND = "TypeKind"

M.NATURE_ID = "NatureId"

M.NatureId = {

Maven = "org.eclipse.m2e.core.maven2Nature",

Gradle = "org.eclipse.buildship.core.gradleprojectnature",

BspGradle = "com.microsoft.gradle.bs.importer.GradleBuildServerProjectNature",

UnmanagedFolder = "org.eclipse.jdt.ls.core.unmanagedFolder",

Java = "org.eclipse.jdt.core.javanature",

}

M.ReadableNature = {

Maven = "maven",

Gradle = "gradle",

BspGradle = "bsp-gradle",

UnmanagedFolder = "unmanagedFolder",

Java = "java",

}

M.NatureIdMap = {

[M.NatureId.Maven] = M.ReadableNature.Maven,

[M.NatureId.Gradle] = M.ReadableNature.Gradle,

[M.NatureId.BspGradle] = M.ReadableNature.BspGradle,

[M.NatureId.UnmanagedFolder] = M.ReadableNature.UnmanagedFolder,

[M.NatureId.Java] = M.ReadableNature.Java,

}

M.ContainerType = {

JRE = "jre",

Maven = "maven",

Gradle = "gradle",

ReferencedLibrary = "referencedLibrary",

Unknown = "",

}

M.ContainerPath = {

JRE = "org.eclipse.jdt.launching.JRE_CONTAINER",

Maven = "org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER",

Gradle = "org.eclipse.buildship.core.gradleclasspathcontainer",

ReferencedLibrary = "REFERENCED_LIBRARIES_PATH",

}

---@enum TreeItemCollapsibleState

M.TreeItemCollapsibleState = {

None = 0,

Collapsed = 1,

Expanded = 2,

}

---@param natureId string

---@return string

M.getProjectType = function(natureId)

return M.NatureIdMap[natureId] or ""

end

---@class DataNode: ExplorerNode

---@field _childrenNodes ExplorerNode[]

---@field _nodeData INodeData

---@field _parent DataNode?

---@field _project DataNode?

---@field _rootNode DataNode?

---@field _hierarchicalPackageNode boolean

---@field _hierarchicalPackageRootNode boolean

---@field _collapsibleState TreeItemCollapsibleState

local DataNode = ExplorerNode:new()

DataNode.__index = DataNode

DataNode._hierarchicalPackageNode = false

DataNode._hierarchicalPackageRootNode = false

---@param nodeData INodeData

---@param parent DataNode?

---@param project DataNode?

---@param rootNode DataNode?

---@return DataNode

function DataNode:new(nodeData, parent, project, rootNode)

local data = setmetatable({}, self)

data._nodeData = nodeData

data._parent = parent

data._project = project

data._rootNode = rootNode

return data

end

---@class TreeItem

---@field label? string

---@field id? string

---@field icon? string

---@field depth? number

---@field description? string

---@field resourceUri? string

---@field command? string

---@field isLast? boolean

---@field data? DataNode

---@field hierarchy? table

local TreeItem = {}

TreeItem.__index = TreeItem

function TreeItem:new()

return setmetatable({}, self)

end

---@return DataNode[]

function DataNode:createHierarchicalPackageRootNode()

local result = {}

local packageData = {}

if self._nodeData.children then

for _, child in ipairs(self._nodeData.children) do

if child:getKind() == NodeKind.Package then

table.insert(packageData, child)

else

table.insert(result, M.createNode(child, self, self._project, self))

end

end

if #packageData > 0 then

local data = hieararchicalPackageNodeData.createHierarchicalNodeDataByPackageList(packageData)

if data and data.children then

for _, child in ipairs(data.children) do

local node = M.createNode(child, self, self._project, self)

table.insert(result, node)

end

end

end

end

return result

end

---@return DataNode[]

function DataNode:createHierarchicalPackageNode()

local result = {}

if self._nodeData.children then

for _, child in ipairs(self._nodeData.children) do

table.insert(result, M.createNode(child, self, self._project, self._rootNode))

end

end

return result

end

function DataNode:createChildNodeList()

local kind = self:kind()

if kind == NodeKind.Workspace then

local result = {}

if self._nodeData.children then

for _, child in ipairs(self._nodeData.children) do

table.insert(result, M.createNode(child, self, nil, nil))

end

end

return result

elseif kind == NodeKind.Project then

local result = {}

local packageData = {}

if self._nodeData.children then

for _, child in ipairs(self._nodeData.children) do

if child:getKind() == NodeKind.Package then

table.insert(packageData, child)

else

table.insert(result, M.createNode(child, self, self, nil))

end

end

if #packageData > 0 then

if M.isHierarchicalView then

local data = hieararchicalPackageNodeData.createHierarchicalNodeDataByPackageList(packageData)

if data and data.children then

for _, child in ipairs(data.children) do

table.insert(result, M.createNode(child, self, self, self))

end

end

else

for _, child in ipairs(packageData) do

table.insert(result, M.createNode(child, self, self, self))

end

end

end

end

return result

elseif kind == NodeKind.Container then

local result = {}

if self._nodeData.children then

for _, child in ipairs(self._nodeData.children) do

table.insert(result, M.createNode(child, self, self._project, nil))

end

end

return result

elseif kind == NodeKind.PackageRoot then

if M.isHierarchicalView then

return self:createHierarchicalPackageRootNode()

else

local result = {}

if self._nodeData.children then

for _, child in ipairs(self._nodeData.children) do

table.insert(result, M.createNode(child, self, self._project, self))

end

end

return result

end

elseif kind == NodeKind.Package then

if M.isHierarchicalView then

return self:createHierarchicalPackageNode()

else

local result = {}

if self._nodeData.children then

for _, child in ipairs(self._nodeData.children) do

table.insert(result, M.createNode(child, self, self._project, self._rootNode))

end

end

return result

end

elseif kind == NodeKind.Folder then

local result = {}

if self._nodeData.children then

for _, child in ipairs(self._nodeData.children) do

table.insert(result, M.createNode(child, self, self._project, self._rootNode))

end

end

return result

elseif kind == NodeKind.PrimaryType then

return nil

else

return nil

end

end

function DataNode:loadData()

local kind = self:kind()

if kind == NodeKind.Workspace then

return jdtls.getProjects(self._nodeData:getUri())

elseif kind == NodeKind.Project then

return jdtls.getPackageData({

kind = NodeKind.Project,

projectUri = self._nodeData:getUri(),

})

elseif kind == NodeKind.Container then

return jdtls.getPackageData({

kind = NodeKind.Container,

projectUri = self._project._nodeData:getUri(),

path = self._nodeData:getPath(),

})

elseif kind == NodeKind.PackageRoot then

return jdtls.getPackageData({

kind = NodeKind.PackageRoot,

projectUri = self._project._nodeData:getUri(),

rootPath = self._nodeData:getPath(),

handlerIdentifier = self._nodeData:getHandlerIdentifier(),

isHierarchicalView = M.isHierarchicalView,

})

elseif kind == NodeKind.Package then

return jdtls.getPackageData({

kind = NodeKind.Package,

projectUri = self._project._nodeData:getUri(),

path = self._nodeData:getName(),

handlerIdentifier = self._nodeData:getHandlerIdentifier(),

})

elseif kind == NodeKind.Folder then

return jdtls.getPackageData({

kind = NodeKind.Folder,

projectUri = self._project._nodeData:getUri(),

path = self._nodeData:getPath(),

rootPath = self._rootNode and self._rootNode._nodeData:getPath() or nil,

handlerIdentifier = self._rootNode and self._rootNode._nodeData:getHandlerIdentifier(),

})

elseif kind == NodeKind.PrimaryType then

return nil

elseif kind == NodeKind.Folder then

return jdtls.getPackageData({

kind = NodeKind.Folder,

projectUri = self._project._nodeData:getUri(),

path = self._nodeData:getPath(),

rootPath = self._rootNode and self._rootNode._nodeData:getPath() or nil,

handlerIdentifier = self._rootNode and self._rootNode._nodeData:getHandlerIdentifier() or nil,

})

else

return nil

end

end

function DataNode:icon()

return icons.get_icon(self)

end

function DataNode:kind()

return self._nodeData:getKind()

end

function DataNode:typeKind()

return self._nodeData:getMetaData() and self._nodeData:getMetaData()[M.K_TYPE_KIND] or nil

end

function DataNode:sort()

table.sort(self._childrenNodes, function(a, b)

---@diagnostic disable: undefined-field

if a._nodeData:getKind() and b._nodeData:getKind() and a._nodeData:getName() and b._nodeData:getName() then

if a._nodeData:getKind() == b._nodeData:getKind() then

return a._nodeData:getName() < b._nodeData:getName()

else

return a._nodeData:getKind() < b._nodeData:getKind()

end

end

return false

end)

end

---@param paths INodeData[]

function DataNode:baseRevealPaths(paths)

if #paths == 0 then

return self

end

---@type DataNode[]

local childNodeData = table.remove(paths, 1)

---@type DataNode[]

local children = self:getChildren()

---@type DataNode[]?

local childNode = vim.tbl_filter(function(child)

return childNodeData:getName() == child._nodeData:getName() and childNodeData:getPath() == child._nodeData:getPath()

end, children)

childNode = (childNode and #childNode > 0) and childNode[1] or nil

return (childNode and #paths > 0) and childNode:revealPaths(paths) or childNode

end

---@param uri string

---@return boolean

local function is_workspace_file(uri)

local rootPath = jdtls.root_dir()

if vim.startswith(uri, "file:/") then

local path = vim.uri_to_fname(uri)

return path == rootPath or vim.startswith(path, rootPath)

end

return false

end

---@param paths INodeData[]

function DataNode:revealPaths(paths)

if #paths == 0 then

return self

end

self._collapsibleState = M.TreeItemCollapsibleState.Expanded

local kind = self:kind()

if kind == NodeKind.Project then

if not self._nodeData:getUri() then

return

end

if is_workspace_file(self._nodeData:getUri()) then

return self:baseRevealPaths(paths)

end

local childNodeData = paths[1]

---@type DataNode[]

local children = self:getChildren()

---@type DataNode[]?

local childNode = vim.tbl_filter(function(child)

return vim.startswith(childNodeData:getName(), child._nodeData:getName() .. ".")

or childNodeData:getName() == child._nodeData:getName()

end, children)

---@type DataNode?

childNode = (childNode and #childNode > 0) and childNode[1] or nil

if childNode and childNode._hierarchicalPackageNode then

table.remove(paths, 1)

end

return (childNode and #paths > 0) and childNode:revealPaths(paths) or childNode

elseif kind == NodeKind.PackageRoot then

if self._hierarchicalPackageRootNode then

local hierarchicalNodeData = paths[1]

---@type DataNode[]

local children = self:getChildren()

---@type DataNode[]?

local childNode = vim.tbl_filter(function(child)

return vim.startswith(hierarchicalNodeData:getName(), child._nodeData:getName() .. ".")

or hierarchicalNodeData:getName() == child._nodeData:getName()

end, children)

---@type DataNode?

childNode = (childNode and #childNode > 0) and childNode[1] or nil

if childNode and not childNode._hierarchicalPackageNode then

table.remove(paths, 1)

end

return (childNode and #paths > 0) and childNode:revealPaths(paths) or childNode

else

return self:baseRevealPaths(paths)

end

elseif kind == NodeKind.Package and self._hierarchicalPackageNode then

local hierarchicalNodeData = paths[1]

if hierarchicalNodeData:getName() == self._nodeData:getName() then

table.remove(paths, 1)

return self:baseRevealPaths(paths)

else

---@type DataNode[]

local children = self:getChildren()

---@type DataNode[]?

local childNode = vim.tbl_filter(function(child)

return vim.startswith(hierarchicalNodeData:getName(), child._nodeData:getName() .. ".")

or hierarchicalNodeData:getName() == child._nodeData:getName()

end, children)

---@type DataNode?

childNode = (childNode and #childNode > 0) and childNode[1] or nil

return (childNode and #paths > 0) and childNode:revealPaths(paths) or nil

end

else

return self:baseRevealPaths(paths)

end

end

local function uniqBy(arr, fn)

local seen = {}

local result = {}

for _, value in ipairs(arr) do

local key = fn(value)

if not seen[key] then

seen[key] = true

table.insert(result, value)

end

end

return result

end

---@return ExplorerNode[]

function DataNode:getChildren()

if self:kind() == NodeKind.Package then

local data = self:loadData()

if data then

if self._nodeData.children then

for _, child in ipairs(data) do

table.insert(self._nodeData.children, child)

end

self._nodeData.children = uniqBy(self._nodeData.children, function(child)

return child:getPath() .. child:getName()

end)

else

self._nodeData.children = data

end

self._childrenNodes = self:createChildNodeList() or {}

self:sort()

end

return self._childrenNodes

else

if not self._nodeData.children then

local data = self:loadData()

self._nodeData.children = data

self._childrenNodes = self:createChildNodeList() or {}

self:sort()

end

return self._childrenNodes

end

end

M.DataNode = DataNode

---@param nodeData INodeData

---@param parent DataNode?

---@param project DataNode?

---@param rootNode DataNode?

M.createNode = function(nodeData, parent, project, rootNode)

local kind = nodeData:getKind()

if kind == NodeKind.Workspace then

return DataNode:new(nodeData, parent, project, rootNode)

elseif kind == NodeKind.Project then

return DataNode:new(nodeData, parent, project, rootNode)

elseif kind == NodeKind.Container then

if not parent or not project then

vim.notify("Container node must have parent and project", vim.log.levels.ERROR)

return nil

end

return DataNode:new(nodeData, parent, project, rootNode)

elseif kind == NodeKind.PackageRoot then

if not parent or not project then

vim.notify("Package root node must have parent and project", vim.log.levels.ERROR)

return nil

end

local data = DataNode:new(nodeData, parent, project, rootNode)

if M.isHierarchicalView then

data._hierarchicalPackageRootNode = true

end

return data

elseif kind == NodeKind.Package then

if not parent or not project or not rootNode then

vim.notify("Package node must have parent, project and root node", vim.log.levels.ERROR)

return nil

end

local data = DataNode:new(nodeData, parent, project, rootNode)

if M.isHierarchicalView then

data._hierarchicalPackageNode = true

end

return data

elseif kind == NodeKind.PrimaryType then

if nodeData:getMetaData() and nodeData:getMetaData()[M.K_TYPE_KIND] then

if not parent then

vim.notify("Primary type node must have parent", vim.log.levels.ERROR)

return nil

end

return DataNode:new(nodeData, parent, project, rootNode)

end

elseif kind == NodeKind.Folder then

if not parent or not project then

vim.notify("Folder node must have parent and project.", vim.log.levels.ERROR)

return nil

end

return DataNode:new(nodeData, parent, project, rootNode)

elseif kind == NodeKind.CompilationUnit or kind == NodeKind.ClassFile or kind == NodeKind.File then

if not parent then

vim.notify("File node must have parent", vim.log.levels.ERROR)

return nil

end

return DataNode:new(nodeData, parent, project, rootNode)

end

end

function DataNode:isUnmanagedFolder()

local natureIds = self._nodeData:getMetaData() and self._nodeData:getMetaData()[M.NATURE_ID] or {}

for _, natureId in ipairs(natureIds) do

if natureId == M.NatureId.UnmanagedFolder then

return true

end

end

return false

end

function DataNode:getContainerType()

local containerPath = self._nodeData:getPath() or ""

if containerPath.startsWith(M.ContainerPath.JRE) then

return M.ContainerType.JRE

elseif containerPath.startsWith(M.ContainerPath.Maven) then

return M.ContainerType.Maven

elseif containerPath.startsWith(M.ContainerPath.Gradle) then

return M.ContainerType.Gradle

elseif containerPath.startsWith(M.ContainerPath.ReferencedLibrary) and self._project:isUnmanagedFolder() then

return M.ContainerType.ReferencedLibrary

end

return M.ContainerType.Unknown

end

function DataNode:description()

--TODO

end

function DataNode:command()

--TODO

end

---@return boolean

function DataNode:hasChildren()

local kind = self:kind()

if

kind == NodeKind.CompilationUnit

or kind == NodeKind.ClassFile

or kind == NodeKind.File

or kind == NodeKind.PrimaryType

then

return false

end

return true

end

---@return TreeItemCollapsibleState

function DataNode:collapsibleState()

if not self._collapsibleState then

if self:hasChildren() then

self._collapsibleState = M.TreeItemCollapsibleState.Collapsed

end

end

return self._collapsibleState

end

function TreeItem:collapsibleState()

return self.data:collapsibleState()

end

---@return boolean

function TreeItem:is_foldable()

return self:collapsibleState() == M.TreeItemCollapsibleState.Collapsed

or self:collapsibleState() == M.TreeItemCollapsibleState.Expanded

end

---@return boolean

function TreeItem:is_expanded()

return self:collapsibleState() == M.TreeItemCollapsibleState.Expanded

end

---@return boolean

function TreeItem:is_collapsed()

return self:collapsibleState() == M.TreeItemCollapsibleState.Collapsed

end

function TreeItem:expanded()

if not self:is_foldable() then

return

end

if self:is_expanded() then

return

end

self.data._collapsibleState = M.TreeItemCollapsibleState.Expanded

self.data:getChildren()

end

function TreeItem:collapsed()

if not self:is_foldable() then

return

end

if self:is_collapsed() then

return

end

self.data._collapsibleState = M.TreeItemCollapsibleState.Collapsed

end

function TreeItem:foldToggle()

if self:is_expanded() then

self:collapsed()

else

self:expanded()

end

end

---是否是文件可以打开

function TreeItem:canOpen()

local kind = self.data:kind()

return kind == NodeKind.PrimaryType or kind == NodeKind.ClassFile or kind == NodeKind.File

end

function DataNode:getTreeItem()

local item = TreeItem:new()

item.label = self._nodeData:getDisplayName() or self._nodeData:getName()

item.description = self:description()

-- item.icon = self:icon()

item.command = self:command()

item.data = self

if self._nodeData:getUri() then

local kind = self:kind()

if

kind == NodeKind.Project

or kind == NodeKind.PackageRoot

or kind == NodeKind.Package

or kind == NodeKind.PrimaryType

or kind == NodeKind.CompilationUnit

or kind == NodeKind.ClassFile

or kind == NodeKind.Folder

or kind == NodeKind.File

then

item.resourceUri = self._nodeData:getUri()

end

end

return item

end

return M