const (
    // LatestVersion signifies the latest available version in requests to the
    // proxy client.
    LatestVersion = "latest"

    // MainVersion represents the main branch.
    MainVersion = "main"

    // MasterVersion represents the master branch.
    MasterVersion = "master"

    // UnknownModulePath signifies that the module path for a given package
    // path is ambiguous or not known. This is because requests to the
    // frontend can come in the form of <import-path>[@<version>], and it is
    // not clear which part of the import-path is the module path.
    UnknownModulePath = "unknownModulePath"
)

const (
    ExperimentDirectoryTree        = "directory-tree"
    ExperimentNotAtLatest          = "not-at-latest"
    ExperimentRedirectedFromBanner = "redirected-from-banner"
)

const StringFieldMissing = "!MISSING"

var DefaultBranches = map[string]bool{
    MainVersion:   true,
    MasterVersion: true,
}

var Experiments = map[string]string{
    ExperimentDirectoryTree:        "Enable the directory tree layout on the unit page.",
    ExperimentNotAtLatest:          "Enable the display of a 'not at latest' badge.",
    ExperimentRedirectedFromBanner: "Display banner with path that request was redirected from.",
}

type DataSource interface {

    // GetNestedModules returns the latest major version of all nested modules
    // given a modulePath path prefix.
    GetNestedModules(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
    // GetUnit returns information about a directory, which may also be a
    // module and/or package. The module and version must both be known.
    GetUnit(ctx context.Context, pathInfo *UnitMeta, fields FieldSet) (_ *Unit, err error)
    // GetUnitMeta returns information about a path.
    GetUnitMeta(ctx context.Context, path, requestedModulePath, requestedVersion string) (_ *UnitMeta, err error)
    // GetModuleReadme gets the readme for the module.
    GetModuleReadme(ctx context.Context, modulePath, resolvedVersion string) (*Readme, error)

    // GetLatestInfo gets information about the latest versions of a unit and module.
    // See LatestInfo for documentation.
    GetLatestInfo(ctx context.Context, unitPath, modulePath string) (LatestInfo, error)
}

type Documentation struct {
    // The values of the GOOS and GOARCH environment variables used to parse the
    // package.
    GOOS     string
    GOARCH   string
    Synopsis string
    Source   []byte // encoded ast.Files; see godoc.Package.Encode
}

type Experiment struct {

    // Name is the name of the feature.
    Name string

    // Rollout is the percentage of requests enrolled in the experiment.
    Rollout uint

    // Description provides a description of the experiment.
    Description string
}

type FieldSet int64

const (
    WithMain FieldSet = 1 << iota
    WithImports
    WithLicenses
)

const AllFields FieldSet = -1

const MinimalFields FieldSet = 0

type IndexVersion struct {
    Path      string
    Version   string
    Timestamp time.Time
}

type LatestInfo struct {
    // MinorVersion is the latest minor version for the unit, regardless of
    // module.
    MinorVersion string

    // MinorModulePath is the module path for MinorVersion.
    MinorModulePath string

    // UnitExistsAtMinor is whether the unit exists at the latest minor version
    // of the module
    UnitExistsAtMinor bool

    // MajorModulePath is the path of the latest module path in the series.
    // For example, in the module path "github.com/casbin/casbin", there
    // is another module path with a greater major version
    // "github.com/casbin/casbin/v3". This field will be
    // "github.com/casbin/casbin/v3" or the input module path if no later module
    // path was found.
    MajorModulePath string

    // MajorUnitPath is the path of the unit in the latest major version of the
    // module, if it exists. For example, if the module is M, the unit is M/U,
    // and the latest major version is 3, then is field is "M/v3/U". If the module version
    // at MajorModulePath does not contain this unit, then it is the module path."
    MajorUnitPath string
}

type Module struct {
    ModuleInfo
    // Licenses holds all licenses within this module version, including those
    // that may be contained in nested subdirectories.
    Licenses []*licenses.License
    Units    []*Unit
}

type ModuleInfo struct {
    ModulePath        string
    Version           string
    CommitTime        time.Time
    IsRedistributable bool
    HasGoMod          bool // whether the module zip has a go.mod file
    SourceInfo        *source.Info
}

type ModuleVersionState struct {
    ModulePath string
    Version    string

    // IndexTimestamp is the timestamp received from the Index for this version,
    // which should correspond to the time this version was committed to the
    // Index.
    IndexTimestamp time.Time
    // CreatedAt is the time this version was originally inserted into the
    // module version state table.
    CreatedAt time.Time

    // Status is the most recent HTTP status code received from the Fetch service
    // for this version, or nil if no request to the fetch service has been made.
    Status int
    // Error is the most recent HTTP response body received from the Fetch
    // service, for a response with an unsuccessful status code. It is used for
    // debugging only, and has no semantic significance.
    Error string
    // TryCount is the number of times a fetch of this version has been
    // attempted.
    TryCount int
    // LastProcessedAt is the last time this version was updated with a result
    // from the fetch service.
    LastProcessedAt *time.Time
    // NextProcessedAfter is the next time a fetch for this version should be
    // attempted.
    NextProcessedAfter time.Time

    // AppVersion is the value of the GAE_VERSION environment variable, which is
    // set by app engine. It is a timestamp in the format 20190709t112655 that
    // is close to, but not the same as, the deployment time. For example, the
    // deployment time for the above timestamp might be Jul 9, 2019, 11:29:59 AM.
    AppVersion string

    // GoModPath is the path declared in the go.mod file.
    GoModPath string

    // NumPackages it the number of packages that were processed as part of the
    // module (regardless of whether the processing was successful).
    NumPackages *int
}

type PackageMeta struct {
    Path              string
    Name              string
    Synopsis          string
    IsRedistributable bool
    Licenses          []*licenses.Metadata // metadata of applicable licenses
}

type PackageVersionState struct {
    PackagePath string
    ModulePath  string
    Version     string
    Status      int
    Error       string
}

type Readme struct {
    Filepath string
    Contents string
}

type SearchResult struct {
    Name        string
    PackagePath string
    ModulePath  string
    Version     string
    Synopsis    string
    Licenses    []string

    CommitTime time.Time
    // Score is used to sort items in an array of SearchResult.
    Score float64

    // NumImportedBy is the number of packages that import PackagePath.
    NumImportedBy uint64

    // NumResults is the total number of packages that were returned for this
    // search.
    NumResults uint64
    // Approximate reports whether NumResults is an approximate count. NumResults
    // can be approximate if search scanned only a subset of documents, and
    // result count is estimated using the hyperloglog algorithm.
    Approximate bool
}

type Unit struct {
    UnitMeta
    Readme          *Readme
    Documentation   *Documentation
    Subdirectories  []*PackageMeta
    Imports         []string
    LicenseContents []*licenses.License
    NumImports      int
    NumImportedBy   int
}

type UnitMeta struct {
    // Unit level information
    //
    Path              string
    Name              string
    IsRedistributable bool
    Licenses          []*licenses.Metadata

    // Module level information
    //
    Version    string
    ModulePath string
    CommitTime time.Time
    SourceInfo *source.Info
    HasGoMod   bool
}

type VersionMap struct {
    ModulePath       string
    RequestedVersion string
    ResolvedVersion  string
    GoModPath        string
    Status           int
    Error            string
    UpdatedAt        time.Time
}