//
//  ContentView.swift
//  gloss
//
//  Created by Saint on 10/23/22.
//

import SwiftUI
import GRDB
import GRDBQuery
import Introspect
import os
let logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "network")

// var curBook = "John"

extension UserDefaults {

    public func optionalInt(forKey defaultName: String) -> Int? {
        let defaults = self
        if let value = defaults.value(forKey: defaultName) {
            return value as? Int
        }
        return nil
    }

    public func optionalBool(forKey defaultName: String) -> Bool? {
        let defaults = self
        if let value = defaults.value(forKey: defaultName) {
            return value as? Bool
        }
        return nil
    }
}

extension UINavigationController {
    override open func viewDidLoad() {
        super.viewDidLoad()

    let standard = UINavigationBarAppearance()
    standard.backgroundColor = .red //When you scroll or you have title (small one)

    let compact = UINavigationBarAppearance()
    compact.backgroundColor = .green //compact-height

    let scrollEdge = UINavigationBarAppearance()
    scrollEdge.backgroundColor = .blue //When you have large title

    navigationBar.standardAppearance = standard
    navigationBar.compactAppearance = compact
    navigationBar.scrollEdgeAppearance = scrollEdge
 }
}

struct BlueButtonStyle: ButtonStyle {

  func makeBody(configuration: Self.Configuration) -> some View {
    configuration.label
        .font(.headline)
        .frame(width: 160)
        .contentShape(Rectangle())
        .foregroundColor(configuration.isPressed ? Color.white.opacity(0.5) : Color.black)
        .background(configuration.isPressed ? Color.purple.opacity(0.5) : Color.purple)
        .listRowBackground(configuration.isPressed ? Color.blue.opacity(0.5) : Color.black)
  }
}

struct PositionObservingView<Content: View>: View {
    var coordinateSpace: CoordinateSpace
@Binding var position: CGPoint
    @ViewBuilder var content: () -> Content

    var body: some View {
        content()
            .background(GeometryReader { geometry in
                Color.clear.preference(
    key: PreferenceKey.self,
    value: geometry.frame(in: coordinateSpace).origin
)
            })
            .onPreferenceChange(PreferenceKey.self) { position in
                self.position = position
                // Print(self.position)
            }
    }
}


private extension PositionObservingView {
    struct PreferenceKey: SwiftUI.PreferenceKey {
        static var defaultValue: CGPoint { .zero }

        static func reduce(value: inout CGPoint, nextValue: () -> CGPoint) {
            // No-op
        }
    }
}

struct OffsetObservingScrollView<Content: View>: View {
    var axes: Axis.Set = [.vertical]
    var showsIndicators = true
    @Binding var offset: CGPoint
    @ViewBuilder var content: () -> Content

    // The name of our coordinate space doesn't have to be
    // stable between view updates (it just needs to be
    // consistent within this view), so we'll simply use a
    // plain UUID for it:
    private let coordinateSpaceName = UUID()

    var body: some View {
        ScrollView(axes, showsIndicators: showsIndicators) {
            PositionObservingView(
                coordinateSpace: .named(coordinateSpaceName),
                position: Binding(
                    get: { offset },
                    set: { newOffset in
                        offset = CGPoint(
    x: -newOffset.x,
    y: -newOffset.y
)
                    }
                ),
                content: content
            )
        }
        .coordinateSpace(name: coordinateSpaceName)
    }
}


struct SwitchButton : View {
    var ribbon: Ribbon
    // var selectedRibbon: SelectedRibbon

    @Binding var book : String
    @Binding var scrollView : UIScrollView?
    @Binding var scrollOffset : CGFloat
    @Binding var readOffset: CGPoint

    @Environment(\.appDatabase) private var appDatabase


    @Query(SelectedRibbonRequest()) private var sr: [Ribbon]

    @State var saveOffset = CGFloat()
    var body: some View {
        // ForEach(sr) { selectedRibbon in 
        Button(String(sr[0].id!) + " " + String(ribbon.scrollOffset),
        // Button("meow",
               action: {
                   Task {
                       var selectedRibbon = sr[0]
                       Print("SELECTED RIBBON", selectedRibbon) 

                       scrollView!.contentOffset.y = CGFloat(2000) 

                       saveOffset = CGFloat(readOffset.y)
                       Print("selected ribbon", selectedRibbon)
                       Print("view ribbon", ribbon)

                       if (selectedRibbon.id != ribbon.id!) {
                           Print("switching")
                           book = ribbon.book
                           scrollOffset = CGFloat(ribbon.scrollOffset)
                           // scrollOffset = CGFloat(1500)
                           var updateSelectRibbon = SelectedRibbon(id: Int64(1), ribbonId: ribbon.id!)
                           Print("Savingg")
                           Print(updateSelectRibbon)
                           do {
                               _ = try await appDatabase.saveSelectedRibbon(&updateSelectRibbon)
                           } catch  {
                               Print("something wrong")
                           }
                       }

                       Print("saveOffset", saveOffset)
                       var editedRibbon = ribbon
                       editedRibbon.scrollOffset = Int(saveOffset)

                       _ = try await appDatabase.saveRibbon(&editedRibbon)
                       _ = Print("editedRibbon", editedRibbon)
                       _ = Print("ribbon", ribbon)

                       Print("ribbon offset saved")
                   }
               }

        )
        .buttonStyle(BlueButtonStyle())
    }
    // }
}


class ScrollViewHandler: NSObject {
}

extension ScrollViewHandler: UIScrollViewDelegate {
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        print("delegate", scrollView.contentOffset.y)
    }
}





struct ContentView: View {

    @State var viewState = CGSize.zero
    @State var pulledOut = CGSize.zero
    @State var taskTitle : String = "FIRST DOGGG"
    @State var curBook : String = "Matthew"
    // @State var scrollTo1 : Int64? 
    @State var selectedLine : Int64? 
    @State var scrollOffset = CGFloat()

    @State var thisScrollView : UIScrollView?
    @State var initLoad = false

    var scrollDelegate = ScrollViewHandler()

    // @State var selectedRibbon: Ribbon!,
    // @State var selectedRibbon: Ribbon!
    
    // @State var selectedRibbonId = Int64(UserDefaults.standard.optionalInt(forKey: "selectedRibbonId") ?? 1)

    // ribbon
    @Query(SelectedRibbonRequest()) private var selectedRibbon: [Ribbon]

    @State var endedDrag = true

    @State var readOffset = CGPoint()

    @Query(LineRequest(ordering: .byScore, book: "bible.john")) private var lines: [Line]
    

    @Query(RibbonRequest()) private var ribbons: [Ribbon]

    // @Query*RibbonRequest> private var selectedRibbon: [Ribbon]

    // @Query(RibbonRequest(id: Int64(UserDefaults.standard.optionalInt(forKey: "lastRibbonId") ?? 1))) private var selectedRibbon: [Ribbon]
    
    init() {
        UITableView.appearance().backgroundColor = UIColor(Color(red: 0.2, green: 0.2, blue: 0.2))
         // _selectedRibbon = Query(RibbonRequest(id: Int64(UserDefaults.standard.optionalInt(forKey: "lastRibbonId") ?? 1)))
    }
    
    var body: some View {
        GeometryReader { geometry in
            ZStack{
                VStack{
                    Text("cat" + String(selectedRibbon[0].id!))
                    ForEach(ribbons) { ribbon in
                        //ForEach(selectedRibbon) { sr in
                            SwitchButton(ribbon: ribbon,
                                         book: $lines.book,
                                         scrollView:$thisScrollView,
                                         // selectedRibbon:selectedRibbon[0],
                                         scrollOffset: $scrollOffset,
                                         readOffset: $readOffset
                            )
                            .buttonStyle(BlueButtonStyle())
                        //}
                    }
                }
                .frame(width: geometry.size.width, height: geometry.size.height, alignment: .topLeading)
                .background(Color.red)

                // VStack (spacing: 0){
                    ScrollViewReader { proxy in
                        //ScrollableView($offset, animationDuration: 0) {
                        // OffsetObservingScrollView(offset: $readOffset)
                        ScrollView
                        {
                        // List {
                            LazyVStack {
                                ForEach(lines) { line in
                                    Text(String(line.body))
                                        .frame(maxWidth: .infinity, alignment: .leading)
                                        .contentShape(Rectangle())
                                        .font(Font.custom("AveriaSerifLibre-Regular", size: 30))
                                        .listRowBackground(Color(red: 0.2, green: 0.8, blue: 0.2))
                                        .foregroundColor(Color.white)
                                        .listRowInsets(EdgeInsets())
                                        .padding(EdgeInsets(top: 10, leading: 20, bottom: 40, trailing: 20))
                                        .listRowSeparator(.hidden)
                                        .id(line.id!)
                                        .onTapGesture {
                                            selectedLine = line.id!
                                            //Print(selectedLine)
                                        }
                                    // }
                                }
                            }
                            .background(Color(red: 0.2, green: 0.2, blue: 0.2))
                            //.onChange(of: scrollTo1) { scrollTo in
                            //    // scrollTo1 = 0
                            //    let target = scrollTo
                            //    //Print("hellosdf")
                            //    //Print("value:",  target)
                            //    //Print("value2:",  scrollTo)
                            //    proxy.scrollTo(target, anchor: .top)
                            //}
                        }
                        .introspectScrollView { scrollView in
                            //let width = scrollView.contentSize.width - scrollView.frame.width
                            //Print(scrollView.contentOffset.x)
                            Print("introspect")
                            scrollView.delegate = scrollDelegate

                            if (thisScrollView == nil) {
                                thisScrollView = scrollView
                            }

                            // scrollView.contentOffset.y = scrollOffset
                            // if (scrollOffset != scrollView.contentOffset.y) {
                            //     scrollView.contentOffset.y = scrollOffset
                            // }
                        }
                        .listStyle(PlainListStyle())
                        
                    }
                // }
                .background(Color(red: 0.2, green: 0.2, blue: 0.2))
                .frame(width: geometry.size.width - 50)
                .offset(x:30 , y:0)
                .offset(x: pulledOut.width)
                .offset(x: viewState.width, y: viewState.height)
                .gesture(
                    DragGesture()
                    .onChanged { gesture in

                        if (endedDrag) {
                            endedDrag = false
                            scrollOffset = readOffset.y - 20
                            _ = Print("meow")
                        }
                        // logger.error("hello222")
                        // NSLog("hellooo")
                        //Print(viewState.width)
                        viewState.width = gesture.translation.width
                        //offset.y = gesture.translation.width
                        // logger.log("hello")
                    }
                    .onEnded { _ in
                        endedDrag = true
                        var pulledOutWidth = CGFloat(0)
                        if (viewState.width < 0) {
                            pulledOutWidth = CGFloat(0)
                        }
                        else if abs(viewState.width + pulledOut.width ) > 30 {
                            pulledOutWidth = CGFloat(200)
                        } 

                        withAnimation(.spring(response: 0.2)) {
                            pulledOut.width = pulledOutWidth
                            viewState = .zero
                        }
                    }
                )
            }
        }
    }
}


private struct LineRow: View {
    var line: Line
    


    var body: some View {
        HStack {

            //Print("Here I am", line.body)
            Text(line.body)
            Spacer()
        }
    }
}

private let itemFormatter: DateFormatter = {
    let formatter = DateFormatter()
    formatter.dateStyle = .short
    formatter.timeStyle = .medium
    return formatter
}()

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()

        ContentView().environment(\.appDatabase, .random())
    }
}



extension View {
    func Print(_ vars: Any...) -> some View {
        for v in vars { print(v) }
        return EmptyView()
    }
}