package cvss

// Calculated scores
type CalcScores struct {
  Base      float32 `json:"base,omitempty"`
  Temporal  float32 `json:"temp,omitempty"`
  Env       float32 `json:"env,omitempty"`
}

// Calculated severities
type CalcSeverities struct {
  Base      string `json:"base,omitempty"`
  Temporal  string `json:"temp,omitempty"`
  Env       string `json:"env,omitempty"`
}

// Row returned by Calc().
type CalcRow struct {
  // Input string
  String string `json:"string"`

  // vector error
  Error string `json:"error,omitempty"`

  // CVSS version
  Version string `json:"version,omitempty"`

  // CVSS scores
  Scores CalcScores `json:"scores,omitempty"`

  // severities
  Severities CalcSeverities  `json:"severities,omitempty"`
}

// Parse CVSS vector strings and extract the relevant attributes.
func Calc(args []string) []CalcRow {
  rows := make([]CalcRow, len(args))

  for i, s := range(args) {
    // parse vector
    if vec, err := NewVector(s); err != nil {
      // parse failed
      rows[i] = CalcRow {
        String: s,
        Error: err.Error(),
      }
    } else {
      // parse scores
      if scores, err := vec.Scores(); err != nil {
        // parse scores failed
        rows[i] = CalcRow {
          String: s,
          Error: err.Error(),
          Version: vec.Version().String(),
        }
      } else {
        // parse scores succeeded, add to results
        rows[i] = CalcRow {
          String: s,
          Version: vec.Version().String(),

          Scores: CalcScores {
            Base:     scores.Base.Float(),
            Temporal: scores.Temporal.Float(),
            Env:      scores.Env.Float(),
          },

          Severities: CalcSeverities {
            Base:     scores.Base.Severity().String(),
            Temporal: scores.Temporal.Severity().String(),
            Env:      scores.Env.Severity().String(),
          },
        }
      }
    }
  }

  // return results
  return rows
}