struct BoardPhotoView: View {
@Environment(\.presentationMode) var presentationMode
@FetchRequest(entity: Pedalboard.entity(), sortDescriptors: [
    NSSortDescriptor(keyPath: \Pedalboard.name, ascending: true),
    NSSortDescriptor(keyPath: \Pedalboard.imageD, ascending: true)
    ]
) var pedalboards: FetchedResults<Pedalboard>

@State var image : Data = .init(count: 0)

let pedalboard: Pedalboard
let imageArray:[Data]
// Magnification vars
@State private var scale: CGFloat = 1
@State var pageIndex = 0
// drag vars
@State private var position = CGSize.zero
@GestureState private var dragOffset = CGSize.zero

var body: some View {
            
    return
        ZStack {
            Color.newPrimaryColor2
            GeometryReader { proxy in
                VStack(spacing: 10) {
                    Pager(page: self.$pageIndex,
                          data: [0],
                          id: \.self) { page in
                            self.pageView(self.imageArray[page], index:page)
                    }
                    .disableDragging()
                    .itemSpacing(10)
                    //.padding(20)
                    .onPageChanged({ page in
                        withAnimation {
                            self.scale = 1.0
                            self.pageIndex = page
                        }
                    })
                    .frame(width: proxy.size.width,
                           height: proxy.size.height)
                    .background(Color.newPrimaryColor2.opacity(0.3))
                    
                    
                    Spacer()
                    
                  /*  HStack {
                        Spacer()
                        Button(action: {
                            withAnimation {
                                self.scale = 1.0
                                self.pageIndex = max(0, self.pageIndex - 1)
                            }
                        }, label: {
                            HStack(spacing: 10) {
                                Image(systemName: "backward.fill")
                                    .padding()
                                Text("Previous")
                            }
                        }).disabled(self.pageIndex <= 0)
                        Spacer()
                        Button(action: {
                            withAnimation {
                                self.scale = 1.0
                                self.position = .zero
                                self.pageIndex = min(self.imageArray.count - 1, self.pageIndex + 1)
                            }
                        }, label: {
                            HStack(spacing: 10) {
                                Text("Next")
                                Image(systemName: "forward.fill")
                                    .padding()
                            }
                        }).disabled(self.pageIndex >= self.imageArray.count - 1)
                        Spacer()
                    }*/
                    Spacer()
                }
            }
            
    }
}

func pageView(_ imagePic: Data, index: Int) -> some View {
    GeometryReader {reader in
        //Image("pizza1delivery")
        Image(uiImage: UIImage(data: imagePic)!)
        .resizable()
        .scaledToFit()
        .cornerRadius(5)
        .scaleEffect(index == self.pageIndex ? self.scale : 1)
        .shadow(radius: 5)
           
        .animation(.default)
        .offset(index == self.pageIndex ? CGSize(width: self.position.width + self.dragOffset.width, height: self.position.height + self.dragOffset.height) : .zero)
        .gesture(index != self.pageIndex ? nil : self.scale <= 1 ? nil : DragGesture()
            .updating(self.$dragOffset, body: { (value, state, transaction) in
            state = value.translation
        })
        .onEnded({ (value) in
            self.position.height += value.translation.height
            self.position.width += value.translation.width
        })
        )
            
        .gesture(index != self.pageIndex ? nil :MagnificationGesture()
            .onChanged({ (value) in
                print(index)
                self.scale = value.magnitude
            })
            .onEnded({ (value) in
                self.position = .zero
                self.scale = value.magnitude
            })
        )
    }
}
} 
struct BoardPhotoView_Previews: PreviewProvider {
static let moc = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
static var previews: some View {
    let pedalboard = Pedalboard(context: moc)
    // pedalboard.imageD = "sampleBoard"
      return NavigationView {
        BoardPhotoView(pedalboard: pedalboard, imageArray: [pedalboard.imageD!])
    }
}}