rest/src/main/kotlin/com/swagger/rest/controllers/PlatformController.kt

package com.swagger.rest.controllers

import com.swagger.rest.models.Bug
import com.swagger.rest.models.Platform
import com.swagger.rest.models.PlatformInput
import com.swagger.rest.models.PlatformOutput
import com.swagger.rest.repositories.*
import jakarta.persistence.criteria.Predicate
import org.springframework.data.domain.PageRequest
import org.springframework.data.domain.Pageable
import org.springframework.data.domain.Sort
import org.springframework.data.jpa.domain.Specification
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.web.bind.annotation.*

@RestController
@RequestMapping("/api/v1")
class PlatformController(
    private val platformRepository: PlatformRepository,
    private val projectRepository: ProjectRepository,
    private val memberRepository: MemberRepository,
    private val userRepository: UserRepository,
    private val bugRepository: BugRepository
) {
    private fun getSortDirection(direction: String): Sort.Direction {
        if (direction == "asc") {
            return Sort.Direction.ASC
        } else if (direction == "desc") {
            return Sort.Direction.DESC
        }
        return Sort.Direction.ASC
    }

    @GetMapping("/platforms")
    fun getPlatformByProjectId(
        @RequestParam(required = false) project: String? = "",
        @RequestParam(defaultValue = 0.toString()) page: Int,
        @RequestParam(defaultValue = 3.toString()) limit: Int,
        @RequestParam(defaultValue = "platform_id, desc") sort: Array<String>
    ): Any {
        return try {
            val userId = userRepository.getUserByUsername(SecurityContextHolder.getContext().authentication.name)
            val orders: MutableList<Sort.Order> = ArrayList()
            val column = listOf("platform_id", "name", "project_id")
            val sort2 = if (!sort.contains(",")) {
                sort + ",desc"
            } else {
                sort
            }
            if (!column.contains(sort2[0])) {
                ResponseEntity<Platform>(HttpStatus.BAD_REQUEST)
            } else {
                if (sort2[0].contains(",")) {
                    // will sort more than 2 fields
                    // sortOrder="field, direction"
                    for (sortOrder in sort2) {
                        val _sort = sortOrder.split(",".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
                        orders.add(Sort.Order(getSortDirection(_sort[1]), _sort[0]))
                    }
                } else {
                    // sort=[field, direction]
                    orders.add(Sort.Order(getSortDirection(sort2[1]), sort2[0]))
                }
                val pagingSort: Pageable = PageRequest.of(page, limit, Sort.by(orders as List<Sort.Order>))
                val platforms = if (project == null) {
                    platformRepository.findOwnerOrMember(userId.id.toString(), "", pagingSort)
                } else {
                    platformRepository.findOwnerOrMember(userId.id.toString(), project, pagingSort)
                }
//                val platforms = platformRepository.findOwnerOrMember(userId.id.toString(), project, pagingSort)
                val output = platforms.map {
                    PlatformOutput(
                        id = it.id, name = it.name, project = it.project!!.description
                    )
                }
                val ret: List<PlatformOutput?> = output.content
                val response: MutableMap<String, Any> = HashMap()
                response["currentPage"] = platforms.number
                response["totalRecord"] = platforms.totalElements
                response["totalPage"] = platforms.totalPages
                response["results"] = ret
                if (ret.isNotEmpty()) {
                    ResponseEntity(response, HttpStatus.OK)
                } else {
                    arrayOf<String>()
                }
            }
        } catch (e: Exception) {
            e.printStackTrace()
            ResponseEntity(e, HttpStatus.INTERNAL_SERVER_ERROR)
        }
    }

    @GetMapping("/platforms/{id}")
    fun getPlatformById(@PathVariable("id") id: Long): Any {
        val platformData = platformRepository.findById(id)
        val output = platformData.map {
            PlatformOutput(
                id = it.id, name = it.name, project = it.project!!.description
            )
        }
        return if (platformData.isPresent) {
            ResponseEntity<PlatformOutput>(output.get(), HttpStatus.OK)
        } else {
            ResponseEntity<PlatformOutput>(HttpStatus.NOT_FOUND)
        }
    }

    @PostMapping("/platforms")
    fun addPlatformByProjectId(
        @RequestBody platform: PlatformInput
    ): Any {
        val proj = (projectRepository.countByName(platform.project_name))
        return if (proj > 0 && platform.project_name!!.isNotBlank()) {
            val foundProject = projectRepository.findByName(platform.project_name)
            val found = platformRepository.findByName(platform.name, foundProject.id.toString()).size
            val userId = userRepository.getUserByUsername(SecurityContextHolder.getContext().authentication.name)
            val validOwner = projectRepository.validOwner(foundProject.id.toString(), userId.id.toString())
            val validAdmin = memberRepository.validRole(foundProject.id.toString(), userId.id.toString(), "2")
            if (validOwner > 0 || validAdmin > 0) {
                if (platform.name!!.isNotBlank()) {
                    if (platform.name!!.length > 100) {//too long
                        ResponseEntity<Platform>(HttpStatus.PAYLOAD_TOO_LARGE)
                    } else if (found > 0) {//duplicate
                        ResponseEntity<Platform>(HttpStatus.CONFLICT)
                    } else {
                        val newPlatform = Platform()
                        newPlatform.name = platform.name!!.trim()
                        newPlatform.project = foundProject
                        val save = platformRepository.save(newPlatform)
                        if (listOf(save).isNotEmpty()) {
                            val output = PlatformOutput(
                                id = newPlatform.id,
                                name = newPlatform.name,
                                project = newPlatform.project!!.description
                            )
                            ResponseEntity(output, HttpStatus.CREATED)
                        } else {
                            ResponseEntity(null, HttpStatus.INTERNAL_SERVER_ERROR)
                        }
                    }
                } else {//invalid name
                    ResponseEntity<Platform>(HttpStatus.BAD_REQUEST)
                }
            } else {
                ResponseEntity<Platform>(HttpStatus.FORBIDDEN)
            }
        } else {
            ResponseEntity<Platform>(HttpStatus.NOT_FOUND)
        }
    }

    @PutMapping("/platforms/{id}")
    fun updatePlatformById(@PathVariable("id") id: Long, @RequestBody input: PlatformInput): Any {
        val targetProj = projectRepository.countByName(input.project_name)
        return if (targetProj > 0) {
            val targetProject = projectRepository.findByName(input.project_name)//target project
            val platformExist = platformRepository.findById(id)//exist data
            val userId = userRepository.getUserByUsername(SecurityContextHolder.getContext().authentication.name)
            val validOwner = projectRepository.validOwner(targetProject.id.toString(), userId.id.toString())
            val validAdmin = memberRepository.validRole(targetProject.id.toString(), userId.id.toString(), "2")
            if (validOwner > 0 || validAdmin > 0) {
                if (input.name!!.isNotBlank()) {
                    if (input.name!!.length > 100) {//too long
                        ResponseEntity<Platform>(HttpStatus.PAYLOAD_TOO_LARGE)
                    } else if (targetProject.name.isEmpty() || platformExist.isEmpty) {//target project not found
                        ResponseEntity<Platform>(HttpStatus.NOT_FOUND)
                    } else {
                        val check = platformRepository.findByName(input.name, targetProject.id.toString())
                        if (check.isEmpty() || (input.name == platformExist.get().name && targetProject.id.toString() == platformExist.get().project!!.id.toString())) {//tidak ada yg sama
                            val savePlatform = platformExist.get()
                            savePlatform.project = targetProject
                            savePlatform.name = input.name!!.trim()
                            ResponseEntity<Platform>(platformRepository.save(savePlatform), HttpStatus.OK)
                        } else {
                            ResponseEntity<Platform>(HttpStatus.CONFLICT)
                        }
                    }
                } else {
                    ResponseEntity<Platform>(HttpStatus.BAD_REQUEST)
                }
            } else {//invalid name
                ResponseEntity<Platform>(HttpStatus.FORBIDDEN)
            }
        } else {
            ResponseEntity<Platform>(HttpStatus.NOT_FOUND)
        }
    }

    @DeleteMapping("/platforms/{id}")
    fun deletePlatformById(@PathVariable("id") id: Long): Any {
        val count = platformRepository.findById(id).isPresent
        return try {
            if (count) {
                val find = platformRepository.findById(id).get()
                val spec = Specification<Bug> { root, _, builder ->
                    val list: MutableList<Predicate> = mutableListOf()
                    list.add(builder.equal(root.get<Platform>("platform").get<Long>("id"), find.id))
                    builder.and(*list.toTypedArray())
                }
                val used = bugRepository.count(spec)
                val userId = userRepository.getUserByUsername(SecurityContextHolder.getContext().authentication.name)
                val validOwner = projectRepository.validOwner(find.project!!.id.toString(), userId.id.toString())
                val validAdmin =
                    memberRepository.validRole(find.project!!.id.toString(), userId.id.toString(), "2")
                if (validOwner > 0 || validAdmin > 0) {
                    if (used > 0) {
                        ResponseEntity(HttpStatus.RESET_CONTENT)
                    } else if (listOf(find).isNotEmpty()) {
                        platformRepository.deleteById(id)
                        ResponseEntity(HttpStatus.OK)
                    } else {
                        ResponseEntity(HttpStatus.NOT_FOUND)
                    }
                } else {
                    ResponseEntity(HttpStatus.FORBIDDEN)
                }
            } else {
                ResponseEntity(HttpStatus.NOT_FOUND)
            }
        } catch (e: Exception) {
            e.printStackTrace()
            ResponseEntity(e, HttpStatus.INTERNAL_SERVER_ERROR)
        }
    }
}