package analize

import (
	"errors"
	"fmt"
	"time"

	"control/control_case"
	"control/series"
	"gorm.io/gorm"
)

func RunAnalyzeWorker(db *gorm.DB) {
	for {
		var cases []control_case.ControlCase
		if err := db.Where("status = ?", "R").Find(&cases).Error; err != nil {
			fmt.Printf("failed to load cases for analysis: %v\n", err)
			time.Sleep(10 * time.Second)
			continue
		}

		for _, controlCase := range cases {
			if _, err := AnalyzeCSV(db, controlCase.ID, controlCase.Name, controlCase.FooCSVPath()); err != nil {
				fmt.Printf("failed to analyze case %d: %v\n", controlCase.ID, err)
				continue
			}

			if err := db.Model(&control_case.ControlCase{}).Where("id = ?", controlCase.ID).Update("status", "D").Error; err != nil {
				fmt.Printf("failed to mark case %d as done: %v\n", controlCase.ID, err)
			}
		}

		time.Sleep(10 * time.Second)
	}
}

func AnalyzeCSV(db *gorm.DB, caseID uint, caseName, csvPath string) (*Analize, error) {
	data, err := series.ReadCSV(csvPath)
	if err != nil {
		return nil, err
	}
	if len(data.Rows) == 0 {
		return nil, fmt.Errorf("csv has no data rows")
	}

	columns, err := data.NumericColumns("t", "psi_m", "psi_l")
	if err != nil {
		return nil, err
	}
	times, psiM, psiL := columns[0], columns[1], columns[2]

	if len(psiL) == 0 {
		return nil, fmt.Errorf("no numeric rows found in csv")
	}

	psiMax := series.MaxLastHalf(psiM)
	psiLMax := series.MaxLastHalf(psiL)
	omega := series.MainAngularFrequency(times, psiL)

	result := &Analize{
		Name:     fmt.Sprintf("analysis-%d", caseID),
		CaseID:   caseID,
		CaseName: caseName,
		PsiMax:   psiMax,
		PsiLMax:  psiLMax,
		Omega:    omega,
	}

	var existing Analize
	err = db.Where("case_id = ?", caseID).First(&existing).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			if err := db.Create(result).Error; err != nil {
				return nil, err
			}
			return result, nil
		}
		return nil, err
	}

	result.ID = existing.ID
	if err := db.Save(result).Error; err != nil {
		return nil, err
	}
	return result, nil
}