//best effort set location from exif data.
func setLocationFromExif(l *core.LatLon, x *exif.Exif) {
	lat, err := x.Get(exif.GPSLatitude)
	if err != nil || lat.Format() != tiff.RatVal || lat.Count != 3 {
		return
	}
	lon, err := x.Get(exif.GPSLongitude)
	if err != nil || lon.Format() != tiff.RatVal || lon.Count != 3 {
		return
	}
	//we should have 3 rational values. and this lib panics on fail.
	//so we did the checks first.
	//OK it no longer panics, so we need to error check. so we add a helper
	rats := func(tag *tiff.Tag) []*big.Rat {
		r := make([]*big.Rat, 3)
		r[0], _ = tag.Rat(0)
		r[1], _ = tag.Rat(1)
		r[2], _ = tag.Rat(2)
		return r
	}

	l.Lat = toDecimalDegreesFromRat(rats(lat))
	l.Lon = toDecimalDegreesFromRat(rats(lon))
	//l is a pointer, so we have filled in the values now,
	// and do not need to return anything.
}

func tagTime(ex *exif.Exif, ts exif.FieldName) (t time.Time, err error) {
	t = time.Unix(0, 0)
	tg, err := ex.Get(ts)
	if err != nil {
		return
	}
	str_val, err := tg.StringVal()
	if err != nil {
		return
	}
	t, err = time.Parse("2006:01:02 15:04:05", str_val)
	return
}

// Returns pointer to struct GeoFields
// can easily be accessed E.Lat, E.Long etc
func GetGPS(E *exif.Exif) (*GeoFields, error) {

	F := new(GeoFields)

	LatVal, err := E.Get("GPSLatitude")
	if err != nil {
		return nil, err
	}
	F.Lat = FormatGPS(LatVal)

	LongVal, err := E.Get("GPSLongitude")
	if err != nil {
		return nil, err
	}
	F.Long = FormatGPS(LongVal)

	//Need to add more comments. Would help
	LatRefVal, err := E.Get("GPSLatitudeRef") //Lat and LatRef
	if err != nil {
		return nil, err
	}
	F.LatRef = LatRefVal.String()

	LongRefVal, err := E.Get("GPSLongitudeRef")
	if err != nil {
		return nil, err
	}

	F.LongRef = LongRefVal.String()

	// *** Longitude

	return F, nil
}

// Parse the date string from an exif tag and return the year, month and day
// in the format YYYYMMDD.
func (i *ImageObj) getDatePath(tags *exif.Exif) (string, error) {
	value, err := tags.Get(exif.DateTimeOriginal)
	if err != nil {
		return "", err
	}

	dateStr, err := value.StringVal()
	if err != nil {
		return "", err
	}

	dateSlice := strings.SplitN(dateStr, ":", 3)

	return path.Join(dateSlice[0], dateSlice[1]), nil
}

func ImageOrientation(ii *ImageInfo, x *exif.Exif) {
	orientation, err := x.Get(exif.Orientation)
	if err != nil {
		log.Println("o err: ", err)
		return
	}
	or := 0
	if orientation.Val[0] != 0 {
		or = int(orientation.Val[0])
	}
	if orientation.Val[1] != 0 {
		or = int(orientation.Val[1])
	}
	ii.Orientation = or
}

// This is basically a copy of the exif.Exif.DateTime() method, except:
//   * it takes a *time.Location to assume
//   * the caller already assumes there's no timezone offset or GPS time
//     in the EXIF, so any of that code can be ignored.
func exifDateTimeInLocation(x *exif.Exif, loc *time.Location) (time.Time, error) {
	tag, err := x.Get(exif.DateTimeOriginal)
	if err != nil {
		tag, err = x.Get(exif.DateTime)
		if err != nil {
			return time.Time{}, err
		}
	}
	if tag.Format() != tiff.StringVal {
		return time.Time{}, errors.New("DateTime[Original] not in string format")
	}
	const exifTimeLayout = "2006:01:02 15:04:05"
	dateStr := strings.TrimRight(string(tag.Val), "\x00")
	return time.ParseInLocation(exifTimeLayout, dateStr, loc)
}

func tagInt(ex *exif.Exif, ts exif.FieldName) (val int32, err error) {
	val = -1
	tg, err := ex.Get(ts)
	if err != nil {
		return
	}
	if tg.Count != 1 {
		err = errors.New(fmt.Sprintf("Tag count not 1: %s", ts))
		return
	}
	int_val, err := tg.Int(0)
	if err == nil {
		val = int32(int_val)
	}
	return
}

// Parse decodes all Nikon makernote data found in x and adds it to x.
func (_ *nikonV3) Parse(x *exif.Exif) error {
	m, err := x.Get(exif.MakerNote)
	if err != nil {
		return nil
	} else if bytes.Compare(m.Val[:6], []byte("Nikon\000")) != 0 {
		return nil
	}

	// Nikon v3 maker note is a self-contained IFD (offsets are relative
	// to the start of the maker note)
	mkNotes, err := tiff.Decode(bytes.NewReader(m.Val[10:]))
	if err != nil {
		return err
	}
	x.LoadTags(mkNotes.Dirs[0], makerNoteNikon3Fields, false)
	return nil
}

func NewGeoPhotoFromExif(exifData *exif.Exif) GeoPhoto {
	GPSLatitude, _ := exifData.Get(exif.GPSLatitude)
	GPSLatitudeRef, _ := exifData.Get(exif.GPSLatitudeRef)
	GPSLongitude, _ := exifData.Get(exif.GPSLongitude)
	GPSLongitudeRef, _ := exifData.Get(exif.GPSLongitudeRef)
	GPSTimeStamp, _ := exifData.Get(exif.GPSTimeStamp)
	GPSDateStamp, _ := exifData.Get(exif.GPSDateStamp)

	return GeoPhoto{
		GPSLatitude:     GPSLatitude,
		GPSLatitudeRef:  GPSLatitudeRef,
		GPSLongitude:    GPSLongitude,
		GPSLongitudeRef: GPSLongitudeRef,
		GPSTimeStamp:    GPSTimeStamp,
		GPSDateStamp:    GPSDateStamp,
	}
}

// Generate a thumbnail from the given image, save it to S3, and save the record to the DB.
func SaveThumbnail(
	proc func(image.Image, int, int, imaging.ResampleFilter) *image.NRGBA,
	photoId int32,
	photoImage image.Image,
	ex *exif.Exif,
	width, height int32) {

	thumbnail := proc(photoImage, int(width), int(height), imaging.Lanczos)

	// If the EXIF says to, rotate the thumbnail.
	var orientation int = 1
	if ex != nil {
		if orientationTag, err := ex.Get(exif.Orientation); err == nil {
			orientation = int(orientationTag.Int(0))
		}
		if rotateFunc, ok := REORIENTATION_FUNCS[orientation]; ok && rotateFunc != nil {
			thumbnail = rotateFunc(thumbnail)
		}
	}

	var thumbnailBuffer bytes.Buffer
	err := jpeg.Encode(&thumbnailBuffer, thumbnail, nil)
	if err != nil {
		rev.ERROR.Println("Failed to create thumbnail:", err)
		return
	}

	thumbnailModel := &models.Thumbnail{
		PhotoId: photoId,
		Width:   width,
		Height:  height,
	}

	err = PHOTO_BUCKET.PutReader(thumbnailModel.S3Path(),
		&thumbnailBuffer,
		int64(thumbnailBuffer.Len()),
		"image/jpeg",
		s3.PublicRead)
	if err != nil {
		rev.ERROR.Println("Failed to create thumbnail:", err)
		return
	}

	dbm.Insert(thumbnailModel)
}

func (info *ExifInfo) Decode(x *exif.Exif) {

	// normally, don't ignore errors!
	camModel, _ := x.Get(exif.Model)
	info.CameraModel, _ = camModel.StringVal()

	// retrieve first (only) rat. value
	focal, _ := x.Get(exif.FocalLength)
	numer, _, _ := focal.Rat2(0)
	//fmt.Printf("\nFocal : %v/%v", numer, denom)
	info.Focal = numer

	// retrieve first (only) rat. value
	aperture, _ := x.Get(exif.FNumber)
	numer, _, _ = aperture.Rat2(0)
	//fmt.Printf("\nAperture : %v/%v", numer, denom)
	info.Aperture = numer

	iso, _ := x.Get(exif.ISOSpeedRatings)
	//fmt.Printf("\n%v", iso)
	info.ISO = iso.String()

}

func storeImage(rw http.ResponseWriter, req *http.Request) {
	// Appengine
	var c appengine.Context
	// Google Cloud Storage authentication
	var cc gcscontext.Context
	// Google Cloud Storage bucket name
	var bucketName string = ""
	// Google Cloud Storage client
	var client *storage.Client
	// Google Cloud Storage bucket
	var bucketHandle *storage.BucketHandle
	// User uploaded image file name
	var fileName string = uuid.New()
	// Transform user uploaded image to a thumbnail file name
	var fileNameThumbnail string = uuid.New()
	// User uploaded image file type
	var contentType string = ""
	// User uploaded image file raw data
	var b []byte
	// Google Cloud Storage file writer
	var wc *storage.Writer = nil
	// Error
	var err error = nil
	// Result, 0: success, 1: failed
	var r int = http.StatusCreated

	// Set response in the end
	defer func() {
		// Return status. WriteHeader() must be called before call to Write
		if r == http.StatusCreated {
			// Changing the header after a call to WriteHeader (or Write) has no effect.
			// rw.Header().Set("Location", req.URL.String()+"/"+cKey.Encode())
			rw.Header().Set("Location", "http://"+bucketName+".storage.googleapis.com/"+fileName)
			rw.Header().Set("X-Thumbnail", "http://"+bucketName+".storage.googleapis.com/"+fileNameThumbnail)
			rw.WriteHeader(r)
		} else {
			http.Error(rw, http.StatusText(r), r)
		}
	}()

	// To log information in Google APP Engine console
	c = appengine.NewContext(req)

	// Get data from body
	b, err = ioutil.ReadAll(req.Body)
	if err != nil {
		c.Errorf("%s in reading body", err)
		r = http.StatusInternalServerError
		return
	}
	c.Infof("Body length %d bytes, read %d bytes", req.ContentLength, len(b))

	// Determine filename extension from content type
	contentType = req.Header["Content-Type"][0]
	switch contentType {
	case "image/jpeg":
		fileName += ".jpg"
		fileNameThumbnail += ".jpg"
	default:
		c.Errorf("Unknown or unsupported content type '%s'. Valid: image/jpeg", contentType)
		r = http.StatusBadRequest
		return
	}
	c.Infof("Content type %s is received, %s is detected.", contentType, http.DetectContentType(b))

	// Prepare Google Cloud Storage authentication
	cc = gcsappengine.NewContext(req)
	if client, err = storage.NewClient(cc); err != nil {
		c.Errorf("%s in initializing a GCS client", err)
		r = http.StatusInternalServerError
		return
	}
	defer client.Close()

	// Get default bucket
	if bucketName, err = gcsfile.DefaultBucketName(cc); err != nil {
		c.Errorf("%s in getting default GCS bucket name", err)
		r = http.StatusInternalServerError
		return
	}
	bucketHandle = client.Bucket(bucketName)
	c.Infof("APP Engine Version: %s", gcsappengine.VersionID(cc))
	c.Infof("Using bucket name: %s", bucketName)

	// Change default object ACLs
	if err = bucketHandle.DefaultObjectACL().Set(cc, storage.AllUsers, storage.RoleReader); err != nil {
		c.Errorf("%v in saving default object ACL rule for bucket %q", err, bucketName)
		r = http.StatusInternalServerError
		return
	}

	// Store rotated image in Google Cloud Storage
	var in *bytes.Reader = bytes.NewReader(b)
	var x *exif.Exif = nil
	var orientation *tiff.Tag = nil
	var beforeImage image.Image
	var afterImage *image.NRGBA = nil

	// Read EXIF
	if _, err = in.Seek(0, 0); err != nil {
//.........这里部分代码省略.........