// Copyright 2025 The Fuchsia 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 codegen

import (
	"fmt"
	"log"
	"sort"
	"strings"

	"go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen"
)

type PythonType struct {
	fidlgen.Type
	PythonName string
}

type PythonConst struct {
	fidlgen.Const
	PythonName  string
	PythonValue string
	PythonType  PythonType
}

type PythonBits struct {
	fidlgen.Bits
	PythonName    string
	PythonMembers []PythonBitsMember
	Empty         bool
}

type PythonBitsMember struct {
	fidlgen.BitsMember
	PythonName  string
	PythonValue string
}

type PythonEnum struct {
	fidlgen.Enum
	PythonName    string
	PythonMembers []PythonEnumMember
	Empty         bool
	HasZero       bool
}

type PythonEnumMember struct {
	fidlgen.EnumMember
	PythonName  string
	PythonValue string
}

type PythonTable struct {
	fidlgen.Table
	Library       string
	PythonName    string
	PythonMembers []PythonTableMember
}

type PythonTableMember struct {
	fidlgen.TableMember
	PythonType PythonType
	PythonName string
}

type PythonStruct struct {
	fidlgen.Struct
	Library       string
	PythonName    string
	PythonMembers []PythonStructMember
}

type PythonStructMember struct {
	fidlgen.StructMember
	PythonType PythonType
	PythonName string
}

type PythonUnion struct {
	fidlgen.Union
	Library           string
	PythonName        string
	PythonMembers     []PythonUnionMember
	PythonSuccessType *PythonType
}

type PythonUnionMember struct {
	fidlgen.UnionMember
	PythonType PythonType
	PythonName string
}

type PythonAlias struct {
	fidlgen.Alias
	PythonAliasedName string
	PythonName        string
}

type UnsupportedMessage string

type PythonUnsupported struct {
	Identifier fidlgen.EncodedCompoundIdentifier
	PythonName string
	Message    []string
}

type PythonProtocol struct {
	fidlgen.Protocol
	Discoverable           bool
	Marker                 string
	Library                string
	PythonName             string
	PythonMarkerName       string
	PythonClientName       string
	PythonServerName       string
	PythonEventHandlerName string
	PythonMethods          []PythonMethod
}

type PythonMethod struct {
	fidlgen.Method
	HasFrameworkError            bool
	PythonName                   string
	PythonResponseAlias          string
	PythonRequestPayload         *PythonPayload
	PythonRequestIdent           fidlgen.EncodedCompoundIdentifier
	PythonResponsePayload        *PythonPayload
	PythonResponseSuccessPayload *PythonPayload
	PythonResponseIdentifier     fidlgen.EncodedCompoundIdentifier
	EmptyResponse                bool
}

type PythonPayload struct {
	fidlgen.Type
	DeclType         fidlgen.DeclType
	PythonType       PythonType
	PythonParameters []PythonParameter
}

type PythonParameter struct {
	PythonType        PythonType
	PythonName        string
	PythonNoneDefault bool
}

type PythonRoot struct {
	fidlgen.Root
	PythonModuleName       string
	EmptySuccessStructs    map[fidlgen.EncodedCompoundIdentifier]fidlgen.Struct
	PythonTables           map[fidlgen.EncodedCompoundIdentifier]PythonTable
	PythonStructs          map[fidlgen.EncodedCompoundIdentifier]PythonStruct
	ExternalPythonStructs  map[fidlgen.EncodedCompoundIdentifier]PythonStruct
	PythonUnions           map[fidlgen.EncodedCompoundIdentifier]PythonUnion
	PythonAliases          []PythonAlias
	PythonConsts           []PythonConst
	PythonBits             []PythonBits
	PythonEnums            []PythonEnum
	PythonProtocols        []PythonProtocol
	PythonExternalModules  []string
	PythonUnsupportedTypes []PythonUnsupported
}

type compiler struct {
	decls           fidlgen.DeclInfoMap
	library         fidlgen.EncodedLibraryIdentifier
	externalModules map[string]struct{}
	PythonRoot      PythonRoot
}

func (c *compiler) lookupDeclInfo(val fidlgen.EncodedCompoundIdentifier) *fidlgen.DeclInfo {
	if info, ok := c.decls[val]; ok {
		return &info
	}
	log.Fatalf("Identifier missing from DeclInfoMap: %v", val)
	return nil
}

func compileCamelIdentifier(val fidlgen.Identifier) string {
	return fidlgen.ToUpperCamelCase(string(val))
}

func (c *compiler) inExternalLibrary(eci fidlgen.EncodedCompoundIdentifier) bool {
	return eci.LibraryName() != c.library
}

func ToPythonModuleName(eli fidlgen.EncodedLibraryIdentifier) string {
	return fmt.Sprintf("fidl_%s", strings.Join(eli.Parts(), "_"))
}

func (c *compiler) compileDeclIdentifier(val fidlgen.EncodedCompoundIdentifier) *string {
	ci := val.Parse()

	if ci.Member != "" {
		log.Fatalf("Non-empty Member implies this is not a declaration: %v", val)
	}

	var name string
	if c.lookupDeclInfo(val).Type == fidlgen.ConstDeclType {
		name = compileScreamingSnakeIdentifier(ci.Name)
	} else {
		name = compileCamelIdentifier(ci.Name)
	}

	if val.LibraryName() == c.library {
		return &name
	}

	externalModule := ToPythonModuleName(val.LibraryName())
	c.externalModules[externalModule] = struct{}{}
	externalName := fmt.Sprintf("%s.%s", externalModule, name)
	return &externalName
}

func compileSnakeIdentifier(val fidlgen.Identifier) string {
	return fidlgen.ToSnakeCase(string(val))
}

func compileScreamingSnakeIdentifier(val fidlgen.Identifier) string {
	return fidlgen.ConstNameToAllCapsSnake(string(val))
}

func (c *compiler) compileType(val fidlgen.Type, maybeAlias *fidlgen.PartialTypeConstructor) *PythonType {
	if _, ok := c.PythonRoot.EmptySuccessStructs[val.Identifier]; ok {
		return &PythonType{
			Type:       val,
			PythonName: "None",
		}
	}

	name := ""

	if val.Nullable {
		name = "typing.Optional["
	}

	switch val.Kind {
	case fidlgen.IdentifierType:
		// TODO(https://fxbug.dev/394421154): This should be changed to use the enum type itself
		// when we start making breaking changes for these bindings.
		identifier := *c.compileDeclIdentifier(val.Identifier)
		switch c.decls[val.Identifier].Type {
		case fidlgen.BitsDeclType, fidlgen.EnumDeclType:
			name += fmt.Sprintf("int | %s", identifier)
		default:
			name += identifier
		}
	case fidlgen.PrimitiveType:
		subtype := string(val.PrimitiveSubtype)
		if strings.HasPrefix(subtype, "int") || strings.HasPrefix(subtype, "uint") {
			name += "int"
		} else if strings.HasPrefix(subtype, "float") {
			name += "float"
		} else if subtype == "bool" {
			name += "bool"
		} else {
			log.Fatalf("Unknown primitive subtype: %v", val)
		}
	case fidlgen.StringType:
		name += "str"
	case fidlgen.HandleType:
		name += "int"
	case fidlgen.VectorType, fidlgen.ArrayType:
		element_type_ptr := c.compileType(*val.ElementType, val.MaybeFromAlias)
		if element_type_ptr == nil {
			log.Fatalf("Element type not supported")
		}
		element_type := *element_type_ptr
		name += fmt.Sprintf("typing.Sequence[%s]", element_type.PythonName)
	case fidlgen.EndpointType:
		switch val.Role {
		case fidlgen.ClientRole, fidlgen.ServerRole:
			name += "int"
		default:
			log.Fatalf("Unsupported endpoint role: %v", val)
		}
	case fidlgen.InternalType:
		// TODO(https://fxbug.dev/42061151): Remove "transport_error".
		switch val.InternalSubtype {
		case "framework_error", "transport_error":
			name += "fidl.FrameworkError"
		default:
			log.Fatalf("Unrecognized internal type: %v", val)
		}
	default:
		log.Fatalf("Unknown kind: %v", val)
	}
	if val.Nullable {
		name += "]"
	}
	return &PythonType{
		Type:       val,
		PythonName: name,
	}
}

func (c *compiler) compileAlias(val fidlgen.Alias) PythonAlias {
	t := c.compileType(val.Type, val.MaybeFromAlias)
	if t == nil {
		log.Fatalf("Type not supported")
	}

	return PythonAlias{
		Alias:             val,
		PythonAliasedName: t.PythonName,
		PythonName:        *c.compileDeclIdentifier(val.Name),
	}
}

// TODO(https://fxbug.dev/396552135): Add literal tests to conformance test suite.
func (c *compiler) compileLiteral(val fidlgen.Literal) *string {
	var r string
	switch val.Kind {
	case fidlgen.NumericLiteral:
		r = val.Value
	case fidlgen.BoolLiteral:
		if val.Value == "true" {
			r = "True"
			return &r
		} else if val.Value == "false" {
			r = "False"
		} else {
			log.Fatalf("Unknown bool value: %v", val)
		}
	case fidlgen.StringLiteral:
		r = strings.ReplaceAll(val.Value, "\\", "\\\\")
		r = strings.ReplaceAll(r, "\"", "\\\"")
		r = strings.ReplaceAll(r, "'", "\\'")
		r = strings.ReplaceAll(r, "\x00", "\\x00")
		r = fmt.Sprintf("\"\"\"%s\"\"\"", r)
	default:
		log.Fatalf("Unknown literal kind: %v", val)
	}
	return &r
}

func (c *compiler) compileMemberIdentifier(val fidlgen.EncodedCompoundIdentifier) *string {
	ci := val.Parse()
	if ci.Member == "" {
		log.Fatalf("expected a member: %s", val)
	}
	decl := val.DeclName()
	declType := c.lookupDeclInfo(decl).Type
	var member string
	switch declType {
	case fidlgen.BitsDeclType, fidlgen.EnumDeclType:
		member = compileScreamingSnakeIdentifier(ci.Member)
	default:
		log.Fatalf("unexpected decl type: %s", declType)
	}
	member_identifier := fmt.Sprintf("%s.%s", *c.compileDeclIdentifier(decl), member)
	return &member_identifier
}

func (c *compiler) compileConstant(val fidlgen.Constant, typ fidlgen.Type) *string {
	switch val.Kind {
	case fidlgen.LiteralConstant:
		return c.compileLiteral(*val.Literal)
	case fidlgen.BinaryOperator, fidlgen.IdentifierConstant:
		return &val.Value
	}
	log.Fatalf("Failed to compile constant: %v, %v", val, typ)
	return nil
}

func (c *compiler) compileConst(val fidlgen.Const) PythonConst {
	return PythonConst{
		Const:       val,
		PythonName:  *c.compileDeclIdentifier(val.Name),
		PythonValue: *c.compileConstant(val.Value, val.Type),
		PythonType:  *c.compileType(val.Type, nil),
	}
}

func (c *compiler) compileBits(val fidlgen.Bits) PythonBits {
	e := PythonBits{
		Bits:          val,
		PythonName:    *c.compileDeclIdentifier(val.Name),
		PythonMembers: []PythonBitsMember{},
		Empty:         len(val.Members) == 0,
	}
	for _, member_val := range val.Members {
		e.PythonMembers = append(e.PythonMembers, PythonBitsMember{
			BitsMember:  member_val,
			PythonName:  changeIfReserved(compileScreamingSnakeIdentifier(member_val.Name)),
			PythonValue: *c.compileConstant(member_val.Value, val.Type),
		})
	}
	return e
}

func (c *compiler) compileEnum(val fidlgen.Enum) PythonEnum {
	e := PythonEnum{
		Enum:          val,
		PythonName:    *c.compileDeclIdentifier(val.Name),
		PythonMembers: []PythonEnumMember{},
		Empty:         len(val.Members) == 0,
		HasZero:       false,
	}
	for _, member_val := range val.Members {
		var value string
		switch member_val.Value.Kind {
		case fidlgen.LiteralConstant:
			value = *c.compileLiteral(*member_val.Value.Literal)
			e.HasZero = e.HasZero || (value == "0")
		case fidlgen.BinaryOperator, fidlgen.IdentifierConstant:
			value = member_val.Value.Value
		default:
			log.Fatalf("Unknown enum member kind: %v", member_val)
		}

		e.PythonMembers = append(e.PythonMembers, PythonEnumMember{
			EnumMember:  member_val,
			PythonName:  changeIfReserved(compileScreamingSnakeIdentifier(member_val.Name)),
			PythonValue: value,
		})
	}
	return e
}

func (c *compiler) compileTableMember(val fidlgen.TableMember) PythonTableMember {
	t := c.compileType(val.Type, val.MaybeFromAlias)
	if t == nil {
		log.Fatalf("Type not supported")
	}
	return PythonTableMember{
		TableMember: val,
		PythonType:  *t,
		PythonName:  changeIfReserved(compileSnakeIdentifier(val.Name)),
	}
}

func (c *compiler) compileTable(val fidlgen.Table) PythonTable {
	name := *c.compileDeclIdentifier(val.Name)
	python_table := PythonTable{
		Table:         val,
		Library:       string(val.Name.LibraryName()),
		PythonName:    name,
		PythonMembers: []PythonTableMember{},
	}

	for _, v := range val.Members {
		member := c.compileTableMember(v)
		python_table.PythonMembers = append(python_table.PythonMembers, member)
	}

	return python_table
}

func (c *compiler) compileStructMember(val fidlgen.StructMember) (PythonStructMember, *UnsupportedMessage) {
	if _, ok := val.Attributes.LookupAttribute("allow_deprecated_struct_defaults"); ok {
		message := UnsupportedMessage(fmt.Sprintf("%s annotated with allow_deprecated_struct_defaults", val.Name))
		return PythonStructMember{}, &message
	}
	t := c.compileType(val.Type, val.MaybeFromAlias)
	if t == nil {
		message := UnsupportedMessage(fmt.Sprintf("Failed to compile type of %s", val.Name))
		return PythonStructMember{}, &message
	}
	return PythonStructMember{
		StructMember: val,
		PythonType:   *t,
		PythonName:   changeIfReserved(compileSnakeIdentifier(val.Name)),
	}, nil
}

func (c *compiler) compileStruct(val fidlgen.Struct) (PythonStruct, *PythonUnsupported) {
	name := *c.compileDeclIdentifier(val.Name)
	python_struct := PythonStruct{
		Struct:        val,
		Library:       string(val.Name.LibraryName()),
		PythonName:    name,
		PythonMembers: []PythonStructMember{},
	}

	unsupported_message := ""
	for _, v := range val.Members {
		member, message := c.compileStructMember(v)
		if message != nil {
			if unsupported_message != "" {
				unsupported_message += "\n"
			}
			unsupported_message = fmt.Sprintf("%s- %s", unsupported_message, *message)
			continue
		}
		python_struct.PythonMembers = append(python_struct.PythonMembers, member)
	}
	if unsupported_message != "" {
		unsupported := PythonUnsupported{
			Identifier: val.Name,
			PythonName: name,
			Message:    strings.Split(unsupported_message, "\n"),
		}
		return PythonStruct{}, &unsupported
	}

	return python_struct, nil
}

var pythonReservedWords = map[string]struct{}{
	// LINT.IfChange
	// keep-sorted start
	"ArithmeticError":           {}, //
	"AssertionError":            {}, //
	"AttributeError":            {}, //
	"BaseException":             {}, //
	"BaseExceptionGroup":        {}, //
	"BlockingIOError":           {}, //
	"BrokenPipeError":           {}, //
	"BufferError":               {}, //
	"BytesWarning":              {}, //
	"ChildProcessError":         {}, //
	"ConnectionAbortedError":    {}, //
	"ConnectionError":           {}, //
	"ConnectionRefusedError":    {}, //
	"ConnectionResetError":      {}, //
	"DeprecationWarning":        {}, //
	"EOFError":                  {}, //
	"Ellipsis":                  {}, //
	"EncodingWarning":           {}, //
	"EnvironmentError":          {}, //
	"Exception":                 {}, //
	"ExceptionGroup":            {}, //
	"False":                     {}, //
	"FileExistsError":           {}, //
	"FileNotFoundError":         {}, //
	"FloatingPointError":        {}, //
	"FutureWarning":             {}, //
	"GeneratorExit":             {}, //
	"IOError":                   {}, //
	"ImportError":               {}, //
	"ImportWarning":             {}, //
	"IndentationError":          {}, //
	"IndexError":                {}, //
	"InterruptedError":          {}, //
	"IsADirectoryError":         {}, //
	"KeyError":                  {}, //
	"KeyboardInterrupt":         {}, //
	"LookupError":               {}, //
	"MemoryError":               {}, //
	"ModuleNotFoundError":       {}, //
	"NameError":                 {}, //
	"None":                      {}, //
	"NotADirectoryError":        {}, //
	"NotImplemented":            {}, //
	"NotImplementedError":       {}, //
	"OSError":                   {}, //
	"OverflowError":             {}, //
	"PendingDeprecationWarning": {}, //
	"PermissionError":           {}, //
	"ProcessLookupError":        {}, //
	"RecursionError":            {}, //
	"ReferenceError":            {}, //
	"ResourceWarning":           {}, //
	"RuntimeError":              {}, //
	"RuntimeWarning":            {}, //
	"StopAsyncIteration":        {}, //
	"StopIteration":             {}, //
	"SyntaxError":               {}, //
	"SyntaxWarning":             {}, //
	"SystemError":               {}, //
	"SystemExit":                {}, //
	"TabError":                  {}, //
	"TimeoutError":              {}, //
	"True":                      {}, //
	"TypeError":                 {}, //
	"UnboundLocalError":         {}, //
	"UnicodeDecodeError":        {}, //
	"UnicodeEncodeError":        {}, //
	"UnicodeError":              {}, //
	"UnicodeTranslateError":     {}, //
	"UnicodeWarning":            {}, //
	"UserWarning":               {}, //
	"ValueError":                {}, //
	"Warning":                   {}, //
	"ZeroDivisionError":         {}, //
	"abs":                       {}, //
	"aiter":                     {}, //
	"all":                       {}, //
	"and":                       {}, //
	"anext":                     {}, //
	"any":                       {}, //
	"as":                        {}, //
	"ascii":                     {}, //
	"assert":                    {}, //
	"async":                     {}, //
	"await":                     {}, //
	"bin":                       {}, //
	"bool":                      {}, //
	"break":                     {}, //
	"breakpoint":                {}, //
	"bytearray":                 {}, //
	"bytes":                     {}, //
	"callable":                  {}, //
	"case":                      {}, //
	"chr":                       {}, //
	"class":                     {}, //
	"classmethod":               {}, //
	"compile":                   {}, //
	"complex":                   {}, //
	"continue":                  {}, //
	"copyright":                 {}, //
	"credits":                   {}, //
	"def":                       {}, //
	"del":                       {}, //
	"delattr":                   {}, //
	"dict":                      {}, //
	"dir":                       {}, //
	"divmod":                    {}, //
	"elif":                      {}, //
	"else":                      {}, //
	"enumerate":                 {}, //
	"eval":                      {}, //
	"except":                    {}, //
	"exec":                      {}, //
	"exit":                      {}, //
	"filter":                    {}, //
	"finally":                   {}, //
	"float":                     {}, //
	"for":                       {}, //
	"format":                    {}, //
	"from":                      {}, //
	"frozenset":                 {}, //
	"getattr":                   {}, //
	"global":                    {}, //
	"globals":                   {}, //
	"hasattr":                   {}, //
	"hash":                      {}, //
	"help":                      {}, //
	"hex":                       {}, //
	"id":                        {}, //
	"if":                        {}, //
	"import":                    {}, //
	"in":                        {}, //
	"input":                     {}, //
	"int":                       {}, //
	"is":                        {}, //
	"isinstance":                {}, //
	"issubclass":                {}, //
	"iter":                      {}, //
	"lambda":                    {}, //
	"len":                       {}, //
	"license":                   {}, //
	"list":                      {}, //
	"locals":                    {}, //
	"map":                       {}, //
	"match":                     {}, //
	"max":                       {}, //
	"memoryview":                {}, //
	"min":                       {}, //
	"next":                      {}, //
	"nonlocal":                  {}, //
	"not":                       {}, //
	"object":                    {}, //
	"oct":                       {}, //
	"open":                      {}, //
	"or":                        {}, //
	"ord":                       {}, //
	"pass":                      {}, //
	"pow":                       {}, //
	"print":                     {}, //
	"property":                  {}, //
	"quit":                      {}, //
	"raise":                     {}, //
	"range":                     {}, //
	"repr":                      {}, //
	"return":                    {}, //
	"reversed":                  {}, //
	"round":                     {}, //
	"self":                      {}, //
	"set":                       {}, //
	"setattr":                   {}, //
	"slice":                     {}, //
	"sorted":                    {}, //
	"staticmethod":              {}, //
	"str":                       {}, //
	"sum":                       {}, //
	"super":                     {}, //
	"try":                       {}, //
	"tuple":                     {}, //
	"type":                      {}, //
	"vars":                      {}, //
	"while":                     {}, //
	"with":                      {}, //
	"yield":                     {}, //
	"zip":                       {}, //
	// keep-sorted end
	// LINT.ThenChange(//src/developer/ffx/lib/fuchsia-controller/cpp/fidl_codec/utils.h, //tools/fidl/fidlgen_python/codegen/ir.go, //tools/fidl/gidl/backend/python/conformance.go)
}

func changeIfReserved(s string) string {
	if _, ok := pythonReservedWords[s]; ok {
		return s + "_"
	}
	return s
}

func (c *compiler) compileUnionMember(val fidlgen.UnionMember) PythonUnionMember {
	t := c.compileType(val.Type, val.MaybeFromAlias)
	if t == nil {
		log.Fatalf("Type not supported")
	}
	return PythonUnionMember{
		UnionMember: val,
		PythonType:  *t,
		PythonName:  changeIfReserved(compileSnakeIdentifier(val.Name)),
	}
}

func (c *compiler) compileUnion(val fidlgen.Union) PythonUnion {
	name := *c.compileDeclIdentifier(val.Name)
	python_union := PythonUnion{
		Union:         val,
		Library:       string(val.Name.LibraryName()),
		PythonName:    name,
		PythonMembers: []PythonUnionMember{},
	}

	for _, v := range val.Members {
		member := c.compileUnionMember(v)
		python_union.PythonMembers = append(python_union.PythonMembers, member)
		if python_union.IsResult && member.PythonName == "response" {
			python_union.PythonSuccessType = &member.PythonType
		}
	}

	return python_union
}

func (c *compiler) compilePayload(payload fidlgen.Type) *PythonPayload {
	r := PythonPayload{
		Type:             payload,
		DeclType:         c.decls[payload.Identifier].Type,
		PythonType:       *c.compileType(payload, nil),
		PythonParameters: []PythonParameter{},
	}

	switch r.DeclType {
	case fidlgen.StructDeclType:
		if s, ok := c.PythonRoot.PythonStructs[payload.Identifier]; ok {
			for _, field := range s.PythonMembers {
				r.PythonParameters = append(r.PythonParameters, PythonParameter{
					PythonType:        field.PythonType,
					PythonName:        field.PythonName,
					PythonNoneDefault: false,
				})
			}
		} else if s, ok := c.PythonRoot.ExternalPythonStructs[payload.Identifier]; ok {
			for _, field := range s.PythonMembers {
				r.PythonParameters = append(r.PythonParameters, PythonParameter{
					PythonType:        field.PythonType,
					PythonName:        field.PythonName,
					PythonNoneDefault: false,
				})
			}
		}
	case fidlgen.UnionDeclType:
		if u, ok := c.PythonRoot.PythonUnions[payload.Identifier]; ok {
			for _, field := range u.PythonMembers {
				r.PythonParameters = append(r.PythonParameters, PythonParameter{
					PythonType:        field.PythonType,
					PythonName:        field.PythonName,
					PythonNoneDefault: true,
				})
			}
		}
	case fidlgen.TableDeclType:
		if t, ok := c.PythonRoot.PythonTables[payload.Identifier]; ok {
			for _, field := range t.PythonMembers {
				r.PythonParameters = append(r.PythonParameters, PythonParameter{
					PythonType:        field.PythonType,
					PythonName:        field.PythonName,
					PythonNoneDefault: true,
				})
			}
		}
	default:
		log.Fatalf("Unable to compile payload: %v", payload)
	}

	return &r
}

func (c *compiler) compileProtocol(val fidlgen.Protocol) PythonProtocol {
	name := *c.compileDeclIdentifier(val.Name)
	r := PythonProtocol{
		Protocol:               val,
		PythonName:             name,
		Library:                string(c.library),
		PythonMarkerName:       name + "Marker",
		PythonClientName:       name + "Client",
		PythonServerName:       name + "Server",
		PythonEventHandlerName: name + "EventHandler",
	}

	// Compile the marker for discovering a protocol, if it's discoverable,
	// e.g. "fuchsia.developer.ffx.Echo".
	if _, r.Discoverable = val.LookupAttribute("discoverable"); r.Discoverable {
		r.Marker = strings.Trim(val.GetProtocolName(), "\"")
	} else {
		r.Marker = fmt.Sprintf("(nondiscoverable) %s", val.Name)
	}

	for _, v := range val.Methods {
		m := PythonMethod{
			Method:              v,
			HasFrameworkError:   v.HasFrameworkError(),
			PythonName:          changeIfReserved(compileSnakeIdentifier(v.Name)),
			PythonResponseAlias: changeIfReserved(fmt.Sprintf("%sResponse", compileCamelIdentifier(v.Name))),
		}
		if v.RequestPayload == nil {
			m.PythonRequestPayload = nil
		} else {
			m.PythonRequestPayload = c.compilePayload(*v.RequestPayload)
			m.PythonRequestIdent = m.PythonRequestPayload.PythonType.Identifier
		}
		if v.ResponsePayload == nil {
			m.PythonResponsePayload = nil
		} else {
			m.PythonResponsePayload = c.compilePayload(*v.ResponsePayload)
			m.PythonResponseIdentifier = m.PythonResponsePayload.PythonType.Identifier
		}

		if v.HasError || m.HasFrameworkError {
			m.PythonResponseSuccessPayload = c.compilePayload(*v.ValueType)
		}

		if m.HasResponse &&
			(m.PythonResponsePayload == nil ||
				(m.PythonResponseSuccessPayload != nil &&
					m.PythonResponseSuccessPayload.PythonType.PythonName == "None")) {
			m.EmptyResponse = true
		} else {
			m.EmptyResponse = false
		}

		r.PythonMethods = append(r.PythonMethods, m)
	}

	return r
}

func Compile(root fidlgen.Root) PythonRoot {
	root = root.ForBindings("python")
	root = root.ForTransports([]string{"Channel"})
	c := compiler{
		decls:           root.DeclInfo(),
		library:         root.Name,
		externalModules: map[string]struct{}{},
		PythonRoot: PythonRoot{
			Root:                  root,
			PythonModuleName:      ToPythonModuleName(root.Name),
			EmptySuccessStructs:   map[fidlgen.EncodedCompoundIdentifier]fidlgen.Struct{},
			PythonStructs:         map[fidlgen.EncodedCompoundIdentifier]PythonStruct{},
			ExternalPythonStructs: map[fidlgen.EncodedCompoundIdentifier]PythonStruct{},
			PythonUnions:          map[fidlgen.EncodedCompoundIdentifier]PythonUnion{},
			PythonTables:          map[fidlgen.EncodedCompoundIdentifier]PythonTable{},
		},
	}

	// Collect all empty success structs so that all calls to compileType() will return None as
	// their type.
	for _, v := range root.Structs {
		if v.IsEmptySuccessStruct {
			c.PythonRoot.EmptySuccessStructs[v.Name] = v
		}
	}
	// The only known uses of ExternalStructs are from fuchsia.unknown which provides some empty
	// success structs. Otherwise, it seems safe to ignore types in ExternalStructs.
	for _, v := range root.ExternalStructs {
		if v.IsEmptySuccessStruct {
			c.PythonRoot.EmptySuccessStructs[v.Name] = v
		}
		python_struct, python_unsupported := c.compileStruct(v)
		if python_unsupported != nil {
			c.PythonRoot.PythonUnsupportedTypes = append(c.PythonRoot.PythonUnsupportedTypes, *python_unsupported)
		} else {
			c.PythonRoot.ExternalPythonStructs[v.Name] = python_struct
		}
	}

	for _, v := range root.Tables {
		c.PythonRoot.PythonTables[v.Name] = c.compileTable(v)
	}

	for _, v := range root.Structs {
		if v.IsEmptySuccessStruct {
			c.PythonRoot.EmptySuccessStructs[v.Name] = v
		}
		python_struct, python_unsupported := c.compileStruct(v)
		if python_unsupported != nil {
			c.PythonRoot.PythonUnsupportedTypes = append(c.PythonRoot.PythonUnsupportedTypes, *python_unsupported)
		} else {
			c.PythonRoot.PythonStructs[v.Name] = python_struct
		}
	}

	for _, v := range root.Aliases {
		c.PythonRoot.PythonAliases = append(c.PythonRoot.PythonAliases, c.compileAlias(v))
	}

	// TODO(https://fxbug.dev/396552135): Extend the test suite to cover the different variations
	// of bits declarations.
	for _, v := range root.Bits {
		c.PythonRoot.PythonBits = append(c.PythonRoot.PythonBits, c.compileBits(v))
	}

	for _, v := range root.Consts {
		c.PythonRoot.PythonConsts = append(c.PythonRoot.PythonConsts, c.compileConst(v))
	}

	for _, v := range root.Enums {
		c.PythonRoot.PythonEnums = append(c.PythonRoot.PythonEnums, c.compileEnum(v))
	}

	for _, v := range root.Unions {
		// TODO(https://fxbug.dev/394421154): If v is a result, then its creation should
		// be deferred to when the corresponding protocol method is compiled.
		c.PythonRoot.PythonUnions[v.Name] = c.compileUnion(v)
	}

	for _, v := range root.Protocols {
		c.PythonRoot.PythonProtocols = append(c.PythonRoot.PythonProtocols, c.compileProtocol(v))
	}

	// Sort the external modules to make sure the generated file is
	// consistent across builds.
	var externalModules []string
	for k := range c.externalModules {
		externalModules = append(externalModules, k)
	}
	sort.Strings(externalModules)

	for _, k := range externalModules {
		c.PythonRoot.PythonExternalModules = append(c.PythonRoot.PythonExternalModules, k)
	}

	return c.PythonRoot
}