// Copyright 2011 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 main

import (
	"go/ast"
	"go/token"
	"strings"
)

func init() {
	register(timefileinfoFix)
}

var timefileinfoFix = fix{
	"time+fileinfo",
	"2011-11-29",
	timefileinfo,
	`Rewrite for new time and os.FileInfo APIs.

This fix applies some of the more mechanical changes,
but most code will still need manual cleanup.

http://codereview.appspot.com/5392041
http://codereview.appspot.com/5416060
`,
}

var timefileinfoTypeConfig = &TypeConfig{
	Type: map[string]*Type{
		"os.File": {
			Method: map[string]string{
				"Readdir": "func() []*os.FileInfo",
				"Stat":    "func() (*os.FileInfo, error)",
			},
		},
		"time.Time": {
			Method: map[string]string{
				"Seconds":     "time.raw",
				"Nanoseconds": "time.raw",
			},
		},
	},
	Func: map[string]string{
		"ioutil.ReadDir":              "([]*os.FileInfo, error)",
		"os.Stat":                     "(*os.FileInfo, error)",
		"os.Lstat":                    "(*os.FileInfo, error)",
		"time.LocalTime":              "*time.Time",
		"time.UTC":                    "*time.Time",
		"time.SecondsToLocalTime":     "*time.Time",
		"time.SecondsToUTC":           "*time.Time",
		"time.NanosecondsToLocalTime": "*time.Time",
		"time.NanosecondsToUTC":       "*time.Time",
		"time.Parse":                  "(*time.Time, error)",
		"time.Nanoseconds":            "time.raw",
		"time.Seconds":                "time.raw",
	},
}

// timefileinfoIsOld reports whether f has evidence of being
// "old code", from before the API changes.  Evidence means:
//
//	a mention of *os.FileInfo (the pointer)
//	a mention of *time.Time (the pointer)
//	a mention of old functions from package time
//	an attempt to call time.UTC
//
func timefileinfoIsOld(f *ast.File, typeof map[interface{}]string) bool {
	old := false

	// called records the expressions that appear as
	// the function part of a function call, so that
	// we can distinguish a ref to the possibly new time.UTC
	// from the definitely old time.UTC() function call.
	called := make(map[interface{}]bool)

	before := func(n interface{}) {
		if old {
			return
		}
		if star, ok := n.(*ast.StarExpr); ok {
			if isPkgDot(star.X, "os", "FileInfo") || isPkgDot(star.X, "time", "Time") {
				old = true
				return
			}
		}
		if sel, ok := n.(*ast.SelectorExpr); ok {
			if isTopName(sel.X, "time") {
				if timefileinfoOldTimeFunc[sel.Sel.Name] {
					old = true
					return
				}
			}
			if typeof[sel.X] == "os.FileInfo" || typeof[sel.X] == "*os.FileInfo" {
				switch sel.Sel.Name {
				case "Mtime_ns", "IsDirectory", "IsRegular":
					old = true
					return
				case "Name", "Mode", "Size":
					if !called[sel] {
						old = true
						return
					}
				}
			}
		}
		call, ok := n.(*ast.CallExpr)
		if ok && isPkgDot(call.Fun, "time", "UTC") {
			old = true
			return
		}
		if ok {
			called[call.Fun] = true
		}
	}
	walkBeforeAfter(f, before, nop)
	return old
}

var timefileinfoOldTimeFunc = map[string]bool{
	"LocalTime":              true,
	"SecondsToLocalTime":     true,
	"SecondsToUTC":           true,
	"NanosecondsToLocalTime": true,
	"NanosecondsToUTC":       true,
	"Seconds":                true,
	"Nanoseconds":            true,
}

var isTimeNow = map[string]bool{
	"LocalTime":   true,
	"UTC":         true,
	"Seconds":     true,
	"Nanoseconds": true,
}

func timefileinfo(f *ast.File) bool {
	if !imports(f, "os") && !imports(f, "time") && !imports(f, "io/ioutil") {
		return false
	}

	typeof, _ := typecheck(timefileinfoTypeConfig, f)

	if !timefileinfoIsOld(f, typeof) {
		return false
	}

	fixed := false
	walk(f, func(n interface{}) {
		p, ok := n.(*ast.Expr)
		if !ok {
			return
		}
		nn := *p

		// Rewrite *os.FileInfo and *time.Time to drop the pointer.
		if star, ok := nn.(*ast.StarExpr); ok {
			if isPkgDot(star.X, "os", "FileInfo") || isPkgDot(star.X, "time", "Time") {
				fixed = true
				*p = star.X
				return
			}
		}

		// Rewrite old time API calls to new calls.
		// The code will still not compile after this edit,
		// but the compiler will catch that, and the replacement
		// code will be the correct functions to use in the new API.
		if sel, ok := nn.(*ast.SelectorExpr); ok && isTopName(sel.X, "time") {
			fn := sel.Sel.Name
			if fn == "LocalTime" || fn == "Seconds" || fn == "Nanoseconds" {
				fixed = true
				sel.Sel.Name = "Now"
				return
			}
		}

		if call, ok := nn.(*ast.CallExpr); ok {
			if sel, ok := call.Fun.(*ast.SelectorExpr); ok {
				// Rewrite time.UTC but only when called (there's a new time.UTC var now).
				if isPkgDot(sel, "time", "UTC") {
					fixed = true
					sel.Sel.Name = "Now"
					// rewrite time.Now() into time.Now().UTC()
					*p = &ast.CallExpr{
						Fun: &ast.SelectorExpr{
							X:   call,
							Sel: ast.NewIdent("UTC"),
						},
					}
					return
				}

				// Rewrite conversions.
				if ok && isTopName(sel.X, "time") && len(call.Args) == 1 {
					fn := sel.Sel.Name
					switch fn {
					case "SecondsToLocalTime", "SecondsToUTC",
						"NanosecondsToLocalTime", "NanosecondsToUTC":
						fixed = true
						sel.Sel.Name = "Unix"
						call.Args = append(call.Args, nil)
						if strings.HasPrefix(fn, "Seconds") {
							// Unix(sec, 0)
							call.Args[1] = ast.NewIdent("0")
						} else {
							// Unix(0, nsec)
							call.Args[1] = call.Args[0]
							call.Args[0] = ast.NewIdent("0")
						}
						if strings.HasSuffix(fn, "ToUTC") {
							// rewrite call into call.UTC()
							*p = &ast.CallExpr{
								Fun: &ast.SelectorExpr{
									X:   call,
									Sel: ast.NewIdent("UTC"),
								},
							}
						}
						return
					}
				}

				// Rewrite method calls.
				switch typeof[sel.X] {
				case "*time.Time", "time.Time":
					switch sel.Sel.Name {
					case "Seconds":
						fixed = true
						sel.Sel.Name = "Unix"
						return
					case "Nanoseconds":
						fixed = true
						sel.Sel.Name = "UnixNano"
						return
					}

				case "*os.FileInfo", "os.FileInfo":
					switch sel.Sel.Name {
					case "IsDirectory":
						fixed = true
						sel.Sel.Name = "IsDir"
						return
					case "IsRegular":
						fixed = true
						sel.Sel.Name = "IsDir"
						*p = &ast.UnaryExpr{
							Op: token.NOT,
							X:  call,
						}
						return
					}
				}
			}
		}

		// Rewrite subtraction of two times.
		// Cannot handle +=/-=.
		if bin, ok := nn.(*ast.BinaryExpr); ok &&
			bin.Op == token.SUB &&
			(typeof[bin.X] == "time.raw" || typeof[bin.Y] == "time.raw") {
			fixed = true
			*p = &ast.CallExpr{
				Fun: &ast.SelectorExpr{
					X:   bin.X,
					Sel: ast.NewIdent("Sub"),
				},
				Args: []ast.Expr{bin.Y},
			}
		}

		// Rewrite field references for os.FileInfo.
		if sel, ok := nn.(*ast.SelectorExpr); ok {
			if typ := typeof[sel.X]; typ == "*os.FileInfo" || typ == "os.FileInfo" {
				addCall := false
				switch sel.Sel.Name {
				case "Name", "Size", "Mode":
					fixed = true
					addCall = true
				case "Mtime_ns":
					fixed = true
					sel.Sel.Name = "ModTime"
					addCall = true
				}
				if addCall {
					*p = &ast.CallExpr{
						Fun: sel,
					}
					return
				}
			}
		}
	})

	return true
}