// Copyright 2019 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package filedesc

import (

	"fmt"

	"math"

	"sort"

	"sync"

	"google.golang.org/protobuf/internal/genid"

	"google.golang.org/protobuf/encoding/protowire"

	"google.golang.org/protobuf/internal/descfmt"

	"google.golang.org/protobuf/internal/errors"

	"google.golang.org/protobuf/internal/pragma"

	"google.golang.org/protobuf/reflect/protoreflect"

)

func (p *FileImports) Len() int                            { return len(*p) }

func (p *FileImports) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }

func (p *FileImports) ProtoInternal(pragma.DoNotImplement) {}

type Names struct {

	once sync.Once

}

func (p *Names) Len() int                            { return len(p.List) }

func (p *Names) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }

func (p *Names) ProtoInternal(pragma.DoNotImplement) {}

func (p *Names) lazyInit() *Names {

	p.once.Do(func() {

		if len(p.List) > 0 {

			for _, s := range p.List {

				p.has[s] = p.has[s] + 1

			}

		}

	})

	return p

}

// CheckValid reports any errors with the set of names with an error message

// that completes the sentence: "ranges is invalid because it has ..."

func (p *Names) CheckValid() error {

	for s, n := range p.lazyInit().has {

		switch {

		case n > 1:

			return errors.New("duplicate name: %q", s)

		case false && !s.IsValid():

			// NOTE: The C++ implementation does not validate the identifier.

			// See https://github.com/protocolbuffers/protobuf/issues/6335.

			return errors.New("invalid name: %q", s)

		}

	}

	return nil

}

type EnumRanges struct {

	once   sync.Once

}

	for ls := p.lazyInit().sorted; len(ls) > 0; {

		i := len(ls) / 2

		switch r := enumRange(ls[i]); {

		case n < r.Start():

			ls = ls[:i] // search lower

		case n > r.End():

			ls = ls[i+1:] // search upper

		default:

			return true

		}

	}

	return false

}

func (p *EnumRanges) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }

func (p *EnumRanges) ProtoInternal(pragma.DoNotImplement) {}

func (p *EnumRanges) lazyInit() *EnumRanges {

	p.once.Do(func() {

		p.sorted = append(p.sorted, p.List...)

		sort.Slice(p.sorted, func(i, j int) bool {

			return p.sorted[i][0] < p.sorted[j][0]

		})

	})

	return p

}

// CheckValid reports any errors with the set of names with an error message

// that completes the sentence: "ranges is invalid because it has ..."

func (p *EnumRanges) CheckValid() error {

	var rp enumRange

	for i, r := range p.lazyInit().sorted {

		r := enumRange(r)

		switch {

		case !(r.Start() <= r.End()):

			return errors.New("invalid range: %v", r)

		case !(rp.End() < r.Start()) && i > 0:

			return errors.New("overlapping ranges: %v with %v", rp, r)

		}

		rp = r

	}

	return nil

}

type enumRange [2]protoreflect.EnumNumber

func (r enumRange) Start() protoreflect.EnumNumber { return r[0] } // inclusive

func (r enumRange) End() protoreflect.EnumNumber   { return r[1] } // inclusive

func (r enumRange) String() string {

	if r.Start() == r.End() {

		return fmt.Sprintf("%d", r.Start())

	}

	return fmt.Sprintf("%d to %d", r.Start(), r.End())

}

type FieldRanges struct {

	once   sync.Once

}

	for ls := p.lazyInit().sorted; len(ls) > 0; {

		i := len(ls) / 2

		switch r := fieldRange(ls[i]); {

		case n < r.Start():

			ls = ls[:i] // search lower

		case n > r.End():

			ls = ls[i+1:] // search upper

		default:

			return true

		}

	}

	return false

}

func (p *FieldRanges) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }

func (p *FieldRanges) ProtoInternal(pragma.DoNotImplement) {}

func (p *FieldRanges) lazyInit() *FieldRanges {

	p.once.Do(func() {

		p.sorted = append(p.sorted, p.List...)

		sort.Slice(p.sorted, func(i, j int) bool {

			return p.sorted[i][0] < p.sorted[j][0]

		})

	})

	return p

}

// CheckValid reports any errors with the set of ranges with an error message

// that completes the sentence: "ranges is invalid because it has ..."

func (p *FieldRanges) CheckValid(isMessageSet bool) error {

	var rp fieldRange

	for i, r := range p.lazyInit().sorted {

		r := fieldRange(r)

		switch {

		case !isValidFieldNumber(r.Start(), isMessageSet):

			return errors.New("invalid field number: %d", r.Start())

		case !isValidFieldNumber(r.End(), isMessageSet):

			return errors.New("invalid field number: %d", r.End())

		case !(r.Start() <= r.End()):

			return errors.New("invalid range: %v", r)

		case !(rp.End() < r.Start()) && i > 0:

			return errors.New("overlapping ranges: %v with %v", rp, r)

		}

		rp = r

	}

	return nil

}

// isValidFieldNumber reports whether the field number is valid.

// Unlike the FieldNumber.IsValid method, it allows ranges that cover the

// reserved number range.

func isValidFieldNumber(n protoreflect.FieldNumber, isMessageSet bool) bool {

	return protowire.MinValidNumber <= n && (n <= protowire.MaxValidNumber || isMessageSet)

}

// CheckOverlap reports an error if p and q overlap.

func (p *FieldRanges) CheckOverlap(q *FieldRanges) error {

	rps := p.lazyInit().sorted

	rqs := q.lazyInit().sorted

	for pi, qi := 0, 0; pi < len(rps) && qi < len(rqs); {

		rp := fieldRange(rps[pi])

		rq := fieldRange(rqs[qi])

		if !(rp.End() < rq.Start() || rq.End() < rp.Start()) {

			return errors.New("overlapping ranges: %v with %v", rp, rq)

		}

		if rp.Start() < rq.Start() {

			pi++

		} else {

			qi++

		}

	}

	return nil

}

type fieldRange [2]protoreflect.FieldNumber

func (r fieldRange) Start() protoreflect.FieldNumber { return r[0] }     // inclusive

func (r fieldRange) End() protoreflect.FieldNumber   { return r[1] - 1 } // inclusive

func (r fieldRange) String() string {

	if r.Start() == r.End() {

		return fmt.Sprintf("%d", r.Start())

	}

	return fmt.Sprintf("%d to %d", r.Start(), r.End())

}

type FieldNumbers struct {

	once sync.Once

}

	p.once.Do(func() {

		if len(p.List) > 0 {

			for _, n := range p.List {

				p.has[n] = struct{}{}

			}

		}

	})

	_, ok := p.has[n]

	return ok

}

func (p *FieldNumbers) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }

func (p *FieldNumbers) ProtoInternal(pragma.DoNotImplement) {}

type OneofFields struct {

	once   sync.Once

}

func (p *OneofFields) lazyInit() *OneofFields {

	p.once.Do(func() {

		if len(p.List) > 0 {

			for _, f := range p.List {

				// Field names and numbers are guaranteed to be unique.

				p.byName[f.Name()] = f

				p.byJSON[f.JSONName()] = f

				p.byText[f.TextName()] = f

				p.byNum[f.Number()] = f

			}

		}

	})

	return p

}

type SourceLocations struct {

	// List is a list of SourceLocations.

	// The SourceLocation.Next field does not need to be populated

	// as it will be lazily populated upon first need.

	// File is the parent file descriptor that these locations are relative to.

	// If non-nil, ByDescriptor verifies that the provided descriptor

	// is a child of this file descriptor.

	once   sync.Once

	byPath map[pathKey]int

}

	if i, ok := p.lazyInit().byPath[k]; ok {

		return p.List[i]

	}

}

	return p.byKey(newPathKey(path))

}

	if p.File != nil && desc != nil && p.File != desc.ParentFile() {

	}

	var pathArr [16]int32

	path := pathArr[:0]

	for {

		switch desc.(type) {

			// Reverse the path since it was constructed in reverse.

			for i, j := 0, len(path)-1; i < j; i, j = i+1, j-1 {

				path[i], path[j] = path[j], path[i]

			}

			return p.byKey(newPathKey(path))

			path = append(path, int32(desc.Index()))

			desc = desc.Parent()

			switch desc.(type) {

				path = append(path, int32(genid.FileDescriptorProto_MessageType_field_number))

				path = append(path, int32(genid.DescriptorProto_NestedType_field_number))

			default:

			}

			path = append(path, int32(desc.Index()))

			desc = desc.Parent()

			if isExtension {

				switch desc.(type) {

					path = append(path, int32(genid.FileDescriptorProto_Extension_field_number))

					path = append(path, int32(genid.DescriptorProto_Extension_field_number))

				default: