package main

import (
	"os"
	"os/exec"
	//"github.com/atotto/encoding/csv"
	"fmt"
	"time"
	"bufio"
	"strconv"
	"encoding/csv"
)

const (
	timeform string = "2006-01-02 15:04"
	taskfile string = "/tmp/laboravi.export.tasks"
	custfile string = "/tmp/laboravi.export.customers"
	projfile string = "/tmp/laboravi.export.projects"
	billfile string = "/tmp/laboravi.export.bills"
	payfile string  = "/tmp/laboravi.export.payments"
	//taskfile string = "laboravi.export.tasks"
	//custfile string = "laboravi.export.customers"
	//projfile string = "laboravi.export.projects"
)

func ExportPayments(in []Payment) {
	filename := payfile
	file ,err := os.Create(filename)
	checkErr(err)
	defer file.Close()

	w := csv.NewWriter(file)
	defer w.Flush()
	for _,i := range in {
		str := []string{Sint(i.Id),Sint(i.Customerid),Sflo(i.Amount),i.Date.Format(timeform),IntArray2String(i.Billids,";")}
		w.Write(str)
		//w.WriteStruct(i)
	}
}

func ExportBills(in []bill) {
	filename := billfile
	file ,err := os.Create(filename)
	checkErr(err)
	defer file.Close()

	w := csv.NewWriter(file)
	defer w.Flush()
	for _,i := range in {
		tsks, tms, hours, mnys := items2strings(i.items)
		//str := []string{Sint(i.Id),Sint(i.Projectid),i.Start.Format(time.RFC3339),i.Stop.Format(time.RFC3339),i.Taskname,i.Comment,Sint(i.Checkout)}
		str := []string{Sint(i.id),i.identity,i.timerange,Sint(i.project),i.projectname,i.date.Format(timeform),i.paid.Format(timeform),tsks,tms,hours,mnys,Sint(i.paymentid)}
		w.Write(str)
		//w.WriteStruct(i)
	}
}

func ExportTasks(in []Task) {
	filename := taskfile
	file ,err := os.Create(filename)
	checkErr(err)
	defer file.Close()

	w := csv.NewWriter(file)
	defer w.Flush()
	for _,i := range in {
		//str := []string{Sint(i.Id),Sint(i.Projectid),i.Start.Format(time.RFC3339),i.Stop.Format(time.RFC3339),i.Taskname,i.Comment,Sint(i.Checkout)}
		str := []string{Sint(i.Id),Sint(i.Projectid),i.Start.Format(timeform),i.Stop.Format(timeform),i.Taskname,i.Comment,Sint(i.Checkout)}
		w.Write(str)
		//w.WriteStruct(i)
	}
}

func ExportProjects(in []Project) {
	filename := projfile
	file ,err := os.Create(filename)
	checkErr(err)
	defer file.Close()

	w := csv.NewWriter(file)
	defer w.Flush()
	for _,i := range in {
		//str := []string{Sint(i.Id),i.Name,i.Comment,i.First.Format(time.RFC3339),i.Last.Format(time.RFC3339),Sint(i.Finished),Sint(i.Customer)}
		str := []string{Sint(i.Id),i.Name,i.Comment,i.First.Format(timeform),i.Last.Format(timeform),Sint(i.Finished),Sint(i.Customer)}
		w.Write(str)
		//w.Write([]string{" Fuck","Master","Flash"})
		//w.WriteStruct(i)
	}
}

func ExportCustomers(in []Customer) {
	filename := custfile
	file ,err := os.Create(filename)
	checkErr(err)
	defer file.Close()

	w := csv.NewWriter(file)
	defer w.Flush()
	for _,i := range in {
		//str := []string{Sint(i.Id),i.Company,i.Name,i.Address,Sflo(i.Satz),i.Lastbill.Format(time.RFC3339)}
		str := []string{Sint(i.Id),i.Company,i.Name,i.Address,i.Uid,Sflo(i.Satz),i.Lastbill.Format(timeform)}
		w.Write(str)
		//w.WriteStruct(i)
	}
}

func ImportPayments() (pay []Payment) {
	filename := payfile

	f, _ := os.Open(filename)

	// Create a new reader.
	r := csv.NewReader(bufio.NewReader(f))
	lines, err := r.ReadAll()
	checkErr(err)

	for _, line := range lines {
		i, err := strconv.Atoi(line[0])
		checkErr(err)
		icu, err := strconv.Atoi(line[1])
		checkErr(err)
		amt,err := strconv.ParseFloat(line[2],64)
		checkErr(err)
		dat,err := time.Parse(timeform,line[3])
		checkErr(err)
		billi := String2IntArray(line[4],";")

		data := Payment{
			Id: i,
			Customerid: icu,
			Amount: amt,
			Date: dat,
			Billids: billi,
		}
		pay=append(pay,data)
	}
	return
}


// Import an array of Bills from a csv of given filename
func ImportBills() ([]bill) {
	filename := billfile
	//file ,err := os.Create(filename)
	var bll []bill
	//w := NewReader(strings.NewReader())
	f, _ := os.Open(filename)

	// Create a new reader.
	r := csv.NewReader(bufio.NewReader(f))
	//err := r.ReadStructAll(&cust)
	//checkErr(err)
	lines, err := r.ReadAll()
	checkErr(err)

	for _, line := range lines {
		i, err := strconv.Atoi(line[0])
		checkErr(err)
		ide := line[1]
		timr := line[2]
		pr, err := strconv.Atoi(line[3])
		checkErr(err)
		prn := line[4]
		dat,err := time.Parse(timeform,line[6])
		checkErr(err)
		pai,err := time.Parse(timeform,line[5])
		checkErr(err)
		tsks := line[7]
		dats := line[8]
		hrs := line[9]
		mos := line[10]
		pid, err := strconv.Atoi(line[11])
		checkErr(err)

		its := strings2items(tsks,dats,hrs,mos)
		data := bill{
			id: i,
			identity: ide,
			timerange: timr,
			project: pr,
			projectname: prn,
			date: dat,
			paid: pai,
			items: its,
			paymentid: pid,
		}
		bll=append(bll,data)

	}
	return bll
}

// Import an array of Tasks from a csv of given filename
func ImportTasks() ([]Task) {
	filename := taskfile
	//file ,err := os.Create(filename)
	var tsk []Task
	//w := NewReader(strings.NewReader())
	f, _ := os.Open(filename)

	// Create a new reader.
	r := csv.NewReader(bufio.NewReader(f))
	//err := r.ReadStructAll(&cust)
	//checkErr(err)
	lines, err := r.ReadAll()
	checkErr(err)

	for _, line := range lines {
		id, err := strconv.Atoi(line[0])
		checkErr(err)
		pr, err := strconv.Atoi(line[1])
		checkErr(err)
		sta,err := time.Parse(timeform,line[2])
		checkErr(err)
		sto,err := time.Parse(timeform,line[3])
		checkErr(err)
		ch, err := strconv.Atoi(line[6])
		checkErr(err)
		data := Task{
			Id: id,
			Projectid: pr,
			Start: sta,
			Stop: sto,
			Taskname: line[4],
			Comment: line[5],
			Checkout: ch,
		}
		tsk=append(tsk,data)

	}
	return tsk
}

// Import an array of Customers from a csv of given filename
func ImportCustomers() ([]Customer) {
	filename := custfile
	//file ,err := os.Create(filename)
	var cust []Customer
	//w := NewReader(strings.NewReader())
	f, _ := os.Open(filename)

	// Create a new reader.
	r := csv.NewReader(bufio.NewReader(f))
	//err := r.ReadStructAll(&cust)
	//checkErr(err)
	lines, err := r.ReadAll()
	checkErr(err)

	for _, line := range lines {
		id, err := strconv.Atoi(line[0])
		checkErr(err)
		sat,err := strconv.ParseFloat(line[5],64)
		checkErr(err)
		tim,err := time.Parse(timeform,line[6])
		checkErr(err)
		data := Customer{
			Id: id,
			Company: line[1],
			Name: line[2],
			Address: line[3],
			Uid: line[4],
			Satz: sat,
			Lastbill: tim,
		}
		cust=append(cust,data)
	}
	return cust
}

// Import an array of Projects from a csv of given filename
func ImportProjects() (prjs []Project) {
	filename := projfile
	//file ,err := os.Create(filename)
	//w := NewReader(strings.NewReader())
	f, _ := os.Open(filename)

	// Create a new reader.
	r := csv.NewReader(bufio.NewReader(f))
	//err := r.ReadStructAll(&cust)
	//checkErr(err)
	lines, err := r.ReadAll()
	checkErr(err)

	for _, line := range lines {
		id, err := strconv.Atoi(line[0])
		checkErr(err)
		fir,err := time.Parse(timeform,line[3])
		checkErr(err)
		las,err := time.Parse(timeform,line[4])
		checkErr(err)
		fin,err := strconv.Atoi(line[5])
		checkErr(err)
		cu,err := strconv.Atoi(line[6])
		checkErr(err)
		data := Project{
			Id: id,
			Name: line[1],
			Comment: line[2],
			First: fir,
			Last: las,
			Finished: fin,
			Customer: cu,
		}
		prjs=append(prjs,data)
	}
	return
}

func TarExports(filename string) {
	var (
		cmdOut []byte
		err error
	)
	cmd := "tar"
	fln := fmt.Sprintf("/tmp/%s",filename)
	//args := []string{"-cf",filename,"/tmp/laboravi.export.tasks","/tmp/laboravi.export.customers","/tmp/laboravi.export.projects"}
	args := []string{"-cf",fln,taskfile,projfile,custfile,billfile,payfile}
	if cmdOut, err = exec.Command(cmd, args...).Output(); err != nil {
		//panic(err)
	}
	 _ = cmdOut
	cmd = "mv"
	args = []string{fln,"."}
	if cmdOut, err = exec.Command(cmd, args...).Output(); err != nil {
		//panic(err)
	}
	 _ = cmdOut
}

func UnTarExports(filename string) (err error){
	_, err = os.Open(filename)
	if err != nil {
		return
	}
	var (
		cmdOut []byte
		//err error
	)
	cmd := "tar"
	//args := []string{"-xf",filename,"/tmp/laboravi.export.tasks","/tmp/laboravi.export.customers","/tmp/laboravi.export.projects"}
	//args := []string{"-xf",filename,taskfile,projfile,custfile}
	args := []string{"-xf",filename,"-C","/"}
	if cmdOut, err = exec.Command(cmd, args...).Output(); err != nil {
		return
	}
	 _ = cmdOut
	return
}

func PurgeTemps() {
	var (
		cmdOut []byte
		err error
	)
	cmd := "rm"
	//args := []string{"/tmp/laboravi.export.tasks","/tmp/laboravi.export.customers","/tmp/laboravi.export.projects"}
	args := []string{taskfile,projfile,custfile,billfile,payfile}
	//args := []string{"/tmp/laboravi.export.*"}
	if cmdOut, err = exec.Command(cmd, args...).Output(); err != nil {
		//panic(err)
	}
	 _ = cmdOut
}