// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package compliance

// EdgeContextProvider is an interface for injecting edge-specific context
// into walk paths.
type EdgeContextProvider interface {
 // Context returns the context for `edge` when added to `path`.
 Context(lg *LicenseGraph, path TargetEdgePath, edge *TargetEdge) interface{}
}

// NoEdgeContext implements EdgeContextProvider for walks that use no context.
type NoEdgeContext struct{}

// Context returns nil.
func (ctx NoEdgeContext) Context(lg *LicenseGraph, path TargetEdgePath, edge *TargetEdge) interface{} {
 return nil
}

// ApplicableConditionsContext provides the subset of conditions in `universe`
// that apply to each edge in a path.
type ApplicableConditionsContext struct {
 universe LicenseConditionSet
}

// Context returns the LicenseConditionSet applicable to the edge.
func (ctx ApplicableConditionsContext) Context(lg *LicenseGraph, path TargetEdgePath, edge *TargetEdge) interface{} {
 universe := ctx.universe
 if len(path) > 0 {
  universe = path[len(path)-1].ctx.(LicenseConditionSet)
 }
 return conditionsAttachingAcrossEdge(lg, edge, universe)
}

// VisitNode is called for each root and for each walked dependency node by
// WalkTopDown and WalkTopDownBreadthFirst. When VisitNode returns true, WalkTopDown will proceed to walk
// down the dependences of the node
type VisitNode func(lg *LicenseGraph, target *TargetNode, path TargetEdgePath) bool

// WalkTopDown does a top-down walk of `lg` calling `visit` and descending
// into depenencies when `visit` returns true.
func WalkTopDown(ctx EdgeContextProvider, lg *LicenseGraph, visit VisitNode) {
 path := NewTargetEdgePath(32)

 var walk func(fnode *TargetNode)
 walk = func(fnode *TargetNode) {
  visitChildren := visit(lg, fnode, *path)
  if !visitChildren {
   return
  }
  for _, edge := range fnode.edges {
   var edgeContext interface{}
   if ctx == nil {
    edgeContext = nil
   } else {
    edgeContext = ctx.Context(lg, *path, edge)
   }
   path.Push(edge, edgeContext)
   walk(edge.dependency)
   path.Pop()
  }
 }

 for _, r := range lg.rootFiles {
  path.Clear()
  walk(lg.targets[r])
 }
}

// WalkTopDownBreadthFirst performs a Breadth-first top down walk of `lg` calling `visit` and descending
// into depenencies when `visit` returns true.
func WalkTopDownBreadthFirst(ctx EdgeContextProvider, lg *LicenseGraph, visit VisitNode) {
 path := NewTargetEdgePath(32)

 var walk func(fnode *TargetNode)
 walk = func(fnode *TargetNode) {
  edgesToWalk := make(TargetEdgeList, 0, len(fnode.edges))
  for _, edge := range fnode.edges {
   var edgeContext interface{}
   if ctx == nil {
    edgeContext = nil
   } else {
    edgeContext = ctx.Context(lg, *path, edge)
   }
   path.Push(edge, edgeContext)
   if visit(lg, edge.dependency, *path) {
    edgesToWalk = append(edgesToWalk, edge)
   }
   path.Pop()
  }

  for _, edge := range edgesToWalk {
   var edgeContext interface{}
   if ctx == nil {
    edgeContext = nil
   } else {
    edgeContext = ctx.Context(lg, *path, edge)
   }
   path.Push(edge, edgeContext)
   walk(edge.dependency)
   path.Pop()
  }
 }

 path.Clear()
 rootsToWalk := make([]*TargetNode, 0, len(lg.rootFiles))
 for _, r := range lg.rootFiles {
  if visit(lg, lg.targets[r], *path) {
   rootsToWalk = append(rootsToWalk, lg.targets[r])
  }
 }

 for _, rnode := range rootsToWalk {
  walk(rnode)
 }
}

// resolutionKey identifies results from walking a specific target for a
// specific set of conditions.
type resolutionKey struct {
 target *TargetNode
 cs     LicenseConditionSet
}

// WalkResolutionsForCondition performs a top-down walk of the LicenseGraph
// resolving all distributed works for `conditions`.
func WalkResolutionsForCondition(lg *LicenseGraph, conditions LicenseConditionSet) ResolutionSet {
 shipped := ShippedNodes(lg)

 // rmap maps 'attachesTo' targets to the `actsOn` targets and applicable conditions
 rmap := make(map[resolutionKey]ActionSet)

 // cmap identifies previously walked target/condition pairs.
 cmap := make(map[resolutionKey]struct{})

 // result accumulates the resolutions to return.
 result := make(ResolutionSet)
 WalkTopDown(ApplicableConditionsContext{conditions}, lg, func(lg *LicenseGraph, tn *TargetNode, path TargetEdgePath) bool {
  universe := conditions
  if len(path) > 0 {
   universe = path[len(path)-1].ctx.(LicenseConditionSet)
  }

  if universe.IsEmpty() {
   return false
  }
  key := resolutionKey{tn, universe}

  if _, alreadyWalked := cmap[key]; alreadyWalked {
   pure := true
   for _, p := range path {
    target := p.Target()
    tkey := resolutionKey{target, universe}
    if _, ok := rmap[tkey]; !ok {
     rmap[tkey] = make(ActionSet)
    }
    // attach prior walk outcome to ancestor
    for actsOn, cs := range rmap[key] {
     rmap[tkey][actsOn] = cs
    }
    // if prior walk produced results, copy results
    // to ancestor.
    if _, ok := result[tn]; ok && pure {
     if _, ok := result[target]; !ok {
      result[target] = make(ActionSet)
     }
     for actsOn, cs := range result[tn] {
      result[target][actsOn] = cs
     }
     pure = target.IsContainer()
    }
   }
   // if all ancestors are pure aggregates, attach
   // matching prior walk conditions to self. Prior walk
   // will not have done so if any ancestor was not an
   // aggregate.
   if pure {
    match := rmap[key][tn].Intersection(universe)
    if !match.IsEmpty() {
     if _, ok := result[tn]; !ok {
      result[tn] = make(ActionSet)
     }
     result[tn][tn] = match
    }
   }
   return false
  }
  // no need to walk node or dependencies if not shipped
  if !shipped.Contains(tn) {
   return false
  }
  if _, ok := rmap[key]; !ok {
   rmap[key] = make(ActionSet)
  }
  // add self to walk outcome
  rmap[key][tn] = tn.resolution
  cmap[key] = struct{}{}
  cs := tn.resolution
  if !cs.IsEmpty() {
   cs = cs.Intersection(universe)
   pure := true
   for _, p := range path {
    target := p.Target()
    tkey := resolutionKey{target, universe}
    if _, ok := rmap[tkey]; !ok {
     rmap[tkey] = make(ActionSet)
    }
    // copy current node's action into ancestor
    rmap[tkey][tn] = tn.resolution
    // conditionally put matching conditions into
    // result
    if pure && !cs.IsEmpty() {
     if _, ok := result[target]; !ok {
      result[target] = make(ActionSet)
     }
     result[target][tn] = cs
     pure = target.IsContainer()
    }
   }
   // if all ancestors are pure aggregates, attach
   // matching conditions to self.
   if pure && !cs.IsEmpty() {
    if _, ok := result[tn]; !ok {
     result[tn] = make(ActionSet)
    }
    result[tn][tn] = cs
   }
  }
  return true
 })

 return result
}

// WalkActionsForCondition performs a top-down walk of the LicenseGraph
// resolving all distributed works for `conditions`.
func WalkActionsForCondition(lg *LicenseGraph, conditions LicenseConditionSet) ActionSet {
 // amap maps 'actsOn' targets to the applicable conditions
 //
 // amap is the resulting ActionSet
 amap := make(ActionSet)

 for tn := range ShippedNodes(lg) {
  if cs := conditions.Intersection(tn.resolution); !cs.IsEmpty() {
   amap[tn] = cs
  }
 }

 return amap
}