package logfile

import (
	"encoding/csv"
	"encoding/json"
	"fmt"
	"os"
	"strconv"
	"time"

	"github.com/go-flucky/flucky/pkg/sensor"
	"github.com/go-flucky/flucky/pkg/types"
)

type csvLogfile struct {
	logfile string
}

func (cl *csvLogfile) GetLogfile() string {
	return cl.logfile
}

func (cl *csvLogfile) ReadHumidities() ([]*types.Humidity, error) {
	if _, err := os.Stat(cl.logfile); os.IsNotExist(err) {
		return nil, fmt.Errorf("%v: %v", errorLogfileNotFound, cl.logfile)
	}

	humidities := make([]*types.Humidity, 0)

	f, err := os.Open(cl.logfile)
	if err != nil {
		return nil, fmt.Errorf("%v: %v", errorLogfileOpen, cl.logfile)
	}
	defer f.Close()

	jsonDecoder := json.NewDecoder(f)
	err = jsonDecoder.Decode(&humidities)
	if err != nil {
		return nil, fmt.Errorf("%v: %v", errorLogfileDecode, err)
	}

	return humidities, nil
}

func (cl *csvLogfile) ReadTemperatures() ([]*types.Temperature, error) {

	if _, err := os.Stat(cl.logfile); os.IsNotExist(err) {
		return nil, fmt.Errorf("%v %v: %v", errorLogfileNotFound, cl.logfile, err)
	}

	temperatures := make([]*types.Temperature, 0)

	f, err := os.Open(cl.logfile)
	if err != nil {
		return nil, fmt.Errorf("%v %v: %v", errorLogfileOpen, cl.logfile, err)
	}
	defer f.Close()

	r := csv.NewReader(f)
	records, err := r.ReadAll()
	if err != nil {
		return nil, fmt.Errorf("%v %v: %v", errorLogfileDecode, cl.logfile, err)
	}

	for _, record := range records {
		times := make([]time.Time, 0)
		for _, j := range []int{3, 4} {
			time, err := time.Parse(timeFormat, record[j])
			if err != nil {
				return nil, fmt.Errorf("%v %v: %v", errorParseTime, record[j], err)
			}
			times = append(times, time)
		}

		temperatureValue, err := strconv.ParseFloat(record[1], 64)
		if err != nil {
			return nil, fmt.Errorf("%v %v: %v", errorParseFloat, record[1], err)
		}

		measurementUnit, err := sensor.SelectTemperatureMeasurementUnit(record[2])
		if err != nil {
			return nil, fmt.Errorf("%v %v: %v", errorParseMeasurementUnit, record[2], err)
		}

		temperature := &types.Temperature{
			TemperatureID:       record[0],        // 0
			TemperatureValue:    temperatureValue, // 1
			TemperatureUnit:     measurementUnit,  // 2
			TemperatureFromDate: times[0],         // 3
			TemperatureTillDate: times[1],         // 4
			SensorID:            record[5],        // 5
		}

		// Creation date
		temperatureCreationDate, err := time.Parse(timeFormat, record[6])
		if err != nil {
			return nil, fmt.Errorf("%v %v: %v", errorParseTime, record[5], err)
		}
		temperature.CreationDate = &temperatureCreationDate

		if record[7] != "" {
			temperatureUpdateDate, err := time.Parse(timeFormat, record[7])
			if err != nil {
				return nil, fmt.Errorf("%v %v: %v", errorParseTime, record[7], err)
			}

			temperature.UpdateDate = &temperatureUpdateDate
		}

		temperatures = append(temperatures, temperature)
	}

	return temperatures, nil
}

func (cl *csvLogfile) WriteHumidities(humidities []*types.Humidity) error {

	f, err := os.Create(cl.logfile)
	if err != nil {
		return fmt.Errorf("%v: %v", errorLogfileCreate, cl.logfile)
	}
	defer f.Close()

	w := csv.NewWriter(f)

	for _, humidity := range humidities {
		w.Write([]string{
			fmt.Sprintf("%v", humidity.HumidityID),
			fmt.Sprintf("%v", humidity.HumidityValue),
			fmt.Sprintf("%v", humidity.HumidityFromDate.Format(timeFormat)),
			fmt.Sprintf("%v", humidity.HumidityTillDate.Format(timeFormat)),
			fmt.Sprintf("%v", humidity.SensorID),
			fmt.Sprintf("%v", humidity.CreationDate.Format(timeFormat)),
			fmt.Sprintf("%v", humidity.UpdateDate.Format(timeFormat)),
		})
	}

	w.Flush()

	return nil
}

func (cl *csvLogfile) WriteTemperatures(temperatures []*types.Temperature) error {
	f, err := os.Create(cl.logfile)
	if err != nil {
		return fmt.Errorf("%v: %v", errorLogfileCreate, cl.logfile)
	}
	defer f.Close()

	writeCreationDate(temperatures)

	w := csv.NewWriter(f)

	for _, temperature := range temperatures {
		record := make([]string, 0)

		if temperature.UpdateDate != nil {
			record = []string{
				fmt.Sprintf("%v", temperature.TemperatureID),
				fmt.Sprintf("%v", temperature.TemperatureValue),
				fmt.Sprintf("%v", temperature.TemperatureUnit),
				fmt.Sprintf("%v", temperature.TemperatureFromDate.Format(timeFormat)),
				fmt.Sprintf("%v", temperature.TemperatureTillDate.Format(timeFormat)),
				fmt.Sprintf("%v", temperature.SensorID),
				fmt.Sprintf("%v", temperature.CreationDate.Format(timeFormat)),
				fmt.Sprintf("%v", temperature.UpdateDate.Format(timeFormat)),
			}
		} else {
			record = []string{
				fmt.Sprintf("%v", temperature.TemperatureID),
				fmt.Sprintf("%v", temperature.TemperatureValue),
				fmt.Sprintf("%v", temperature.TemperatureUnit),
				fmt.Sprintf("%v", temperature.TemperatureFromDate.Format(timeFormat)),
				fmt.Sprintf("%v", temperature.TemperatureTillDate.Format(timeFormat)),
				fmt.Sprintf("%v", temperature.SensorID),
				fmt.Sprintf("%v", temperature.CreationDate.Format(timeFormat)),
				fmt.Sprintf(""),
			}
		}

		w.Write(record)
	}

	w.Flush()

	return nil
}