package logentries

import (
	"fmt"
	"github.com/hashicorp/terraform/helper/schema"
	logentries "github.com/logentries/le_goclient"
	"strconv"
)

func resourceLogentriesLog() *schema.Resource {

	return &schema.Resource{
		Create: resourceLogentriesLogCreate,
		Read:   resourceLogentriesLogRead,
		Update: resourceLogentriesLogUpdate,
		Delete: resourceLogentriesLogDelete,

		Schema: map[string]*schema.Schema{
			"token": &schema.Schema{
				Type:     schema.TypeString,
				Computed: true,
				ForceNew: true,
			},
			"logset_id": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
				ForceNew: true,
			},
			"name": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
			"filename": &schema.Schema{
				Type:     schema.TypeString,
				Optional: true,
			},
			"retention_period": &schema.Schema{
				Type:     schema.TypeString,
				Optional: true,
				Default:  "ACCOUNT_DEFAULT",
				ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) {
					value := v.(string)
					allowed_values := []string{"1W", "2W", "1M", "2M", "6M", "1Y", "2Y", "UNLIMITED", "ACCOUNT_DEFAULT"}
					if !sliceContains(value, allowed_values) {
						errors = append(errors, fmt.Errorf("Invalid retention period: %s (must be one of: %s)", value, allowed_values))
					}
					return
				},
			},
			"source": &schema.Schema{
				Type:     schema.TypeString,
				Optional: true,
				Default:  "token",
				ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) {
					value := v.(string)
					allowed_values := []string{"token", "syslog", "agent", "api"}
					if !sliceContains(value, allowed_values) {
						errors = append(errors, fmt.Errorf("Invalid log source option: %s (must be one of: %s)", value, allowed_values))
					}
					return
				},
			},
			"type": &schema.Schema{
				Type:     schema.TypeString,
				Default:  "",
				Optional: true,
			},
		},
	}
}

func resourceLogentriesLogCreate(d *schema.ResourceData, meta interface{}) error {
	client := meta.(*logentries.Client)
	retentionPeriod, err := retentionPeriodForEnum(d.Get("retention_period").(string))
	if err != nil {
		return err
	}
	res, err := client.Log.Create(logentries.LogCreateRequest{
		LogSetKey: d.Get("logset_id").(string),
		Name:      d.Get("name").(string),
		Retention: strconv.FormatInt(retentionPeriod, 10),
		Type:      d.Get("type").(string),
		Source:    d.Get("source").(string),
		Filename:  d.Get("filename").(string),
	})

	if err != nil {
		return err
	}

	d.SetId(res.Key)

	return mapLogToSchema(client, res, d)
}

func resourceLogentriesLogRead(d *schema.ResourceData, meta interface{}) error {
	client := meta.(*logentries.Client)
	res, err := client.Log.Read(logentries.LogReadRequest{
		LogSetKey: d.Get("logset_id").(string),
		Key:       d.Id(),
	})
	if err != nil {
		return err
	}

	if res == nil {
		d.SetId("")
		return nil
	}

	return mapLogToSchema(client, res, d)
}

func resourceLogentriesLogUpdate(d *schema.ResourceData, meta interface{}) error {
	client := meta.(*logentries.Client)
	_, err := client.Log.Update(logentries.LogUpdateRequest{
		Key:       d.Id(),
		Name:      d.Get("name").(string),
		Retention: d.Get("retention_period").(string),
		Type:      d.Get("type").(string),
		Source:    d.Get("source").(string),
		Filename:  d.Get("filename").(string),
	})
	if err != nil {
		return err
	}

	return resourceLogentriesLogRead(d, meta)
}

func resourceLogentriesLogDelete(d *schema.ResourceData, meta interface{}) error {
	client := meta.(*logentries.Client)
	err := client.Log.Delete(logentries.LogDeleteRequest{
		LogSetKey: d.Get("logset_id").(string),
		Key:       d.Id(),
	})
	return err
}

func mapLogToSchema(client *logentries.Client, log *logentries.Log, d *schema.ResourceData) error {
	d.Set("token", log.Token)
	d.Set("name", log.Name)
	d.Set("filename", log.Filename)
	retentionEnum, err := enumForRetentionPeriod(log.Retention)
	if err != nil {
		return err
	}
	d.Set("retention_period", retentionEnum)
	d.Set("source", log.Source)
	if log.Type != "" {
		logTypes, err := client.LogType.ReadDefault(logentries.LogTypeListRequest{})
		if err != nil {
			return err
		}
		logType := lookupTypeShortcut(log.Type, logTypes)
		if logType == "" {
			logTypes, err = client.LogType.Read(logentries.LogTypeListRequest{})
			if err != nil {
				return err
			}
			logType = lookupTypeShortcut(log.Type, logTypes)
		}
		d.Set("type", logType)
	}

	return nil
}

func enumForRetentionPeriod(retentionPeriod int64) (string, error) {
	switch retentionPeriod {
	case 604800000:
		return "1W", nil
	case 1209600000:
		return "2W", nil
	case 2678400000:
		return "1M", nil
	case 5356800000:
		return "2M", nil
	case 16070400000:
		return "6M", nil
	case 31536000000:
		return "1Y", nil
	case 63072000000:
		return "2Y", nil
	case 0:
		return "UNLIMITED", nil
	case -1:
		return "ACCOUNT_DEFAULT", nil
	}

	return "", fmt.Errorf("Unknown retention period: %d", retentionPeriod)
}

func retentionPeriodForEnum(retentionPeriodEnum string) (int64, error) {
	switch retentionPeriodEnum {
	case "1W":
		return 604800000, nil
	case "2W":
		return 1209600000, nil
	case "1M":
		return 2678400000, nil
	case "2M":
		return 5356800000, nil
	case "6M":
		return 16070400000, nil
	case "1Y":
		return 31536000000, nil
	case "2Y":
		return 63072000000, nil
	case "UNLIMITED":
		return 0, nil
	case "ACCOUNT_DEFAULT":
		return -1, nil
	}

	return 0, fmt.Errorf("Unknown retention period: %s", retentionPeriodEnum)
}

func lookupTypeShortcut(currentLogKey string, logTypes []logentries.LogType) string {
	for _, logType := range logTypes {
		if logType.Key == currentLogKey {
			return logType.Shortcut
		}
	}
	return ""
}

func sliceContains(a string, list []string) bool {
	for _, b := range list {
		if b == a {
			return true
		}
	}
	return false
}