package dto

import (
	"time"

	"browser.local/platform/domain"
)

type SCUMBindingIdentityDTO struct {
	ServerInstanceID string `json:"serverInstanceId"`
	RunBindingID     string `json:"runBindingId"`
	RunEndpointID    string `json:"runEndpointId"`
	PluginID         string `json:"pluginId"`
	PluginVersion    string `json:"pluginVersion"`
	AdapterVersion   string `json:"adapterVersion"`
	GameVersion      string `json:"gameVersion"`
	DatabaseIdentity string `json:"databaseIdentity"`
}

type SCUMSchemaProbeBoundsDTO struct {
	MaxObjects          int `json:"maxObjects"`
	MaxColumnsPerObject int `json:"maxColumnsPerObject"`
	MaxIndexesPerObject int `json:"maxIndexesPerObject"`
	MaxForeignKeys      int `json:"maxForeignKeys"`
	MaxCardinalityReads int `json:"maxCardinalityReads"`
	MaxSampleRows       int `json:"maxSampleRows"`
	TimeoutMS           int `json:"timeoutMs"`
	MaxResultBytes      int `json:"maxResultBytes"`
}

type SCUMSchemaProbeRequestDTO struct {
	RequestID   string                   `json:"requestId"`
	JobID       string                   `json:"jobId"`
	Binding     SCUMBindingIdentityDTO   `json:"binding"`
	Bounds      SCUMSchemaProbeBoundsDTO `json:"bounds"`
	RequestedAt time.Time                `json:"requestedAt"`
}

type SCUMSchemaProbeDispatchRequest struct {
	IdempotencyKey string `json:"idempotencyKey"`
}

type SCUMSchemaProbeDispatchResponse struct {
	ProbeRequest SCUMSchemaProbeRequestDTO `json:"probeRequest"`
	QueuedJob    RemoteAdapterResponse     `json:"queuedJob"`
}

type SCUMSafeErrorDTO struct {
	Code      string `json:"code"`
	Message   string `json:"message,omitempty"`
	Retryable bool   `json:"retryable"`
}

type SCUMSchemaColumnEvidenceDTO struct {
	NameFingerprint string `json:"nameFingerprint"`
	DeclaredType    string `json:"declaredType"`
	Nullable        *bool  `json:"nullable,omitempty"`
	PrimaryKey      bool   `json:"primaryKey"`
	Ordinal         int    `json:"ordinal"`
}

type SCUMSchemaIndexEvidenceDTO struct {
	NameFingerprint string   `json:"nameFingerprint"`
	Unique          bool     `json:"unique"`
	ColumnHashes    []string `json:"columnHashes"`
}

type SCUMSchemaForeignKeyEvidenceDTO struct {
	FromColumnHash string `json:"fromColumnHash"`
	ToObjectHash   string `json:"toObjectHash"`
	ToColumnHash   string `json:"toColumnHash"`
}

type SCUMSchemaObjectEvidenceDTO struct {
	ObjectHash         string                            `json:"objectHash"`
	Kind               string                            `json:"kind"`
	NameFingerprint    string                            `json:"nameFingerprint"`
	DeclaredColumns    []SCUMSchemaColumnEvidenceDTO     `json:"declaredColumns"`
	Indexes            []SCUMSchemaIndexEvidenceDTO      `json:"indexes"`
	ForeignKeys        []SCUMSchemaForeignKeyEvidenceDTO `json:"foreignKeys"`
	ApproximateRows    *int64                            `json:"approximateRows,omitempty"`
	SampleFingerprints []string                          `json:"sampleFingerprints,omitempty"`
}

type SCUMSchemaProbeResultDTO struct {
	RequestID         string                        `json:"requestId"`
	JobID             string                        `json:"jobId"`
	Binding           SCUMBindingIdentityDTO        `json:"binding"`
	Status            string                        `json:"status"`
	SourceFingerprint string                        `json:"sourceFingerprint,omitempty"`
	SchemaFingerprint string                        `json:"schemaFingerprint,omitempty"`
	ObservedAt        time.Time                     `json:"observedAt"`
	ResultDigest      string                        `json:"resultDigest,omitempty"`
	Objects           []SCUMSchemaObjectEvidenceDTO `json:"objects,omitempty"`
	SafeError         SCUMSafeErrorDTO              `json:"safeError,omitempty"`
	Limits            SCUMSchemaProbeBoundsDTO      `json:"limits"`
}

type SCUMCapabilityGateDTO struct {
	Capability string `json:"capability"`
	State      string `json:"state"`
	Enabled    bool   `json:"enabled"`
	ReasonCode string `json:"reasonCode"`
	Reason     string `json:"reason"`
}

func SCUMSchemaProbeRequestToDomain(value SCUMSchemaProbeRequestDTO) domain.SCUMSchemaProbeRequest {
	return domain.SCUMSchemaProbeRequest{RequestID: value.RequestID, JobID: value.JobID, Binding: scumBindingIdentityToDomain(value.Binding), Bounds: scumProbeBoundsToDomain(value.Bounds), RequestedAt: value.RequestedAt}
}

func SCUMSchemaProbeRequestFromDomain(value domain.SCUMSchemaProbeRequest) SCUMSchemaProbeRequestDTO {
	return SCUMSchemaProbeRequestDTO{RequestID: value.RequestID, JobID: value.JobID, Binding: scumBindingIdentityFromDomain(value.Binding), Bounds: scumProbeBoundsFromDomain(value.Bounds), RequestedAt: value.RequestedAt}
}

func SCUMSchemaProbeRequestPtrFromDomain(value *domain.SCUMSchemaProbeRequest) *SCUMSchemaProbeRequestDTO {
	if value == nil {
		return nil
	}
	result := SCUMSchemaProbeRequestFromDomain(*value)
	return &result
}

func runSQLiteSchemaProbeRequestPtrFromDomain(value *domain.SCUMSchemaProbeRequest) *RunSQLiteSchemaProbeRequestBody {
	if value == nil {
		return nil
	}
	return &RunSQLiteSchemaProbeRequestBody{RequestID: value.RequestID, Binding: scumBindingIdentityFromDomain(value.Binding), Limits: scumProbeBoundsFromDomain(value.Bounds)}
}

func SCUMSchemaProbeDispatchFromDomain(request domain.SCUMSchemaProbeRequest, queued domain.RemoteAdapterResult) SCUMSchemaProbeDispatchResponse {
	return SCUMSchemaProbeDispatchResponse{ProbeRequest: SCUMSchemaProbeRequestFromDomain(request), QueuedJob: RemoteAdapterFromDomain(queued)}
}

func SCUMSchemaProbeResultToDomain(value SCUMSchemaProbeResultDTO) domain.SCUMSchemaProbeResult {
	objects := make([]domain.SCUMSchemaObjectEvidence, len(value.Objects))
	for index, object := range value.Objects {
		columns := make([]domain.SCUMSchemaColumnEvidence, len(object.DeclaredColumns))
		for i, column := range object.DeclaredColumns {
			columns[i] = domain.SCUMSchemaColumnEvidence{NameFingerprint: column.NameFingerprint, DeclaredType: column.DeclaredType, Nullable: column.Nullable, PrimaryKey: column.PrimaryKey, Ordinal: column.Ordinal}
		}
		indexes := make([]domain.SCUMSchemaIndexEvidence, len(object.Indexes))
		for i, item := range object.Indexes {
			indexes[i] = domain.SCUMSchemaIndexEvidence{NameFingerprint: item.NameFingerprint, Unique: item.Unique, ColumnHashes: append([]string(nil), item.ColumnHashes...)}
		}
		foreignKeys := make([]domain.SCUMSchemaForeignKeyEvidence, len(object.ForeignKeys))
		for i, item := range object.ForeignKeys {
			foreignKeys[i] = domain.SCUMSchemaForeignKeyEvidence{FromColumnHash: item.FromColumnHash, ToObjectHash: item.ToObjectHash, ToColumnHash: item.ToColumnHash}
		}
		objects[index] = domain.SCUMSchemaObjectEvidence{ObjectHash: object.ObjectHash, Kind: object.Kind, NameFingerprint: object.NameFingerprint, DeclaredColumns: columns, Indexes: indexes, ForeignKeys: foreignKeys, ApproximateRows: object.ApproximateRows, SampleFingerprints: append([]string(nil), object.SampleFingerprints...)}
	}
	return domain.SCUMSchemaProbeResult{RequestID: value.RequestID, JobID: value.JobID, Binding: scumBindingIdentityToDomain(value.Binding), Status: domain.SCUMCapabilityEvidenceStatus(value.Status), SourceFingerprint: value.SourceFingerprint, SchemaFingerprint: value.SchemaFingerprint, ObservedAt: value.ObservedAt, ResultDigest: value.ResultDigest, Objects: objects, SafeError: domain.SCUMSafeError{Code: domain.SCUMSafeErrorCode(value.SafeError.Code), Message: value.SafeError.Message, Retryable: value.SafeError.Retryable}, Limits: scumProbeBoundsToDomain(value.Limits)}
}

func SCUMSchemaProbeResultPtrToDomain(value *SCUMSchemaProbeResultDTO) *domain.SCUMSchemaProbeResult {
	if value == nil {
		return nil
	}
	result := SCUMSchemaProbeResultToDomain(*value)
	return &result
}

func SCUMSchemaProbeResultFromDomain(value domain.SCUMSchemaProbeResult) SCUMSchemaProbeResultDTO {
	value = domain.CopySCUMSchemaProbeResult(value)
	objects := make([]SCUMSchemaObjectEvidenceDTO, len(value.Objects))
	for index, object := range value.Objects {
		columns := make([]SCUMSchemaColumnEvidenceDTO, len(object.DeclaredColumns))
		for i, column := range object.DeclaredColumns {
			columns[i] = SCUMSchemaColumnEvidenceDTO{NameFingerprint: column.NameFingerprint, DeclaredType: column.DeclaredType, Nullable: column.Nullable, PrimaryKey: column.PrimaryKey, Ordinal: column.Ordinal}
		}
		indexes := make([]SCUMSchemaIndexEvidenceDTO, len(object.Indexes))
		for i, item := range object.Indexes {
			indexes[i] = SCUMSchemaIndexEvidenceDTO{NameFingerprint: item.NameFingerprint, Unique: item.Unique, ColumnHashes: append([]string(nil), item.ColumnHashes...)}
		}
		foreignKeys := make([]SCUMSchemaForeignKeyEvidenceDTO, len(object.ForeignKeys))
		for i, item := range object.ForeignKeys {
			foreignKeys[i] = SCUMSchemaForeignKeyEvidenceDTO{FromColumnHash: item.FromColumnHash, ToObjectHash: item.ToObjectHash, ToColumnHash: item.ToColumnHash}
		}
		objects[index] = SCUMSchemaObjectEvidenceDTO{ObjectHash: object.ObjectHash, Kind: object.Kind, NameFingerprint: object.NameFingerprint, DeclaredColumns: columns, Indexes: indexes, ForeignKeys: foreignKeys, ApproximateRows: object.ApproximateRows, SampleFingerprints: append([]string(nil), object.SampleFingerprints...)}
	}
	return SCUMSchemaProbeResultDTO{RequestID: value.RequestID, JobID: value.JobID, Binding: scumBindingIdentityFromDomain(value.Binding), Status: string(value.Status), SourceFingerprint: value.SourceFingerprint, SchemaFingerprint: value.SchemaFingerprint, ObservedAt: value.ObservedAt, ResultDigest: value.ResultDigest, Objects: objects, SafeError: SCUMSafeErrorDTO{Code: string(value.SafeError.Code), Message: value.SafeError.Message, Retryable: value.SafeError.Retryable}, Limits: scumProbeBoundsFromDomain(value.Limits)}
}

func SCUMSchemaProbeResultPtrFromDomain(value *domain.SCUMSchemaProbeResult) *SCUMSchemaProbeResultDTO {
	if value == nil {
		return nil
	}
	result := SCUMSchemaProbeResultFromDomain(*value)
	return &result
}

func SCUMCapabilityGateFromDomain(value domain.SCUMCapabilityGate) SCUMCapabilityGateDTO {
	return SCUMCapabilityGateDTO{Capability: string(value.Capability), State: string(value.State), Enabled: value.Enabled, ReasonCode: string(value.ReasonCode), Reason: value.Reason}
}

func scumBindingIdentityToDomain(value SCUMBindingIdentityDTO) domain.SCUMBindingIdentity {
	return domain.SCUMBindingIdentity{ServerInstanceID: value.ServerInstanceID, RunBindingID: value.RunBindingID, RunEndpointID: value.RunEndpointID, PluginID: value.PluginID, PluginVersion: value.PluginVersion, AdapterVersion: value.AdapterVersion, GameVersion: value.GameVersion, DatabaseIdentity: value.DatabaseIdentity}
}

func scumBindingIdentityFromDomain(value domain.SCUMBindingIdentity) SCUMBindingIdentityDTO {
	return SCUMBindingIdentityDTO{ServerInstanceID: value.ServerInstanceID, RunBindingID: value.RunBindingID, RunEndpointID: value.RunEndpointID, PluginID: value.PluginID, PluginVersion: value.PluginVersion, AdapterVersion: value.AdapterVersion, GameVersion: value.GameVersion, DatabaseIdentity: value.DatabaseIdentity}
}

func scumProbeBoundsToDomain(value SCUMSchemaProbeBoundsDTO) domain.SCUMSchemaProbeBounds {
	return domain.SCUMSchemaProbeBounds{MaxObjects: value.MaxObjects, MaxColumnsPerObject: value.MaxColumnsPerObject, MaxIndexesPerObject: value.MaxIndexesPerObject, MaxForeignKeys: value.MaxForeignKeys, MaxCardinalityReads: value.MaxCardinalityReads, MaxSampleRows: value.MaxSampleRows, TimeoutMS: value.TimeoutMS, MaxResultBytes: value.MaxResultBytes}
}

func scumProbeBoundsFromDomain(value domain.SCUMSchemaProbeBounds) SCUMSchemaProbeBoundsDTO {
	return SCUMSchemaProbeBoundsDTO{MaxObjects: value.MaxObjects, MaxColumnsPerObject: value.MaxColumnsPerObject, MaxIndexesPerObject: value.MaxIndexesPerObject, MaxForeignKeys: value.MaxForeignKeys, MaxCardinalityReads: value.MaxCardinalityReads, MaxSampleRows: value.MaxSampleRows, TimeoutMS: value.TimeoutMS, MaxResultBytes: value.MaxResultBytes}
}