package fileproperties

class ChangePermissionsBehaviour( val form : ChangePermissionsForm ) : TextBehaviour( form.title ), Promptable {

    init {
        contexts.addAll( contextsForFile( form.fileOrFolder.value) )

        val recurseFlag = if ( form.recurse.value ) "-R" else ""

        val ugo = listOf<String>( "u", "g", "o" )
        val rwx = listOf<String>( "r", "w", "X" )
        val permissionString = StringBuilder().apply {
            for ( y in 0 until 3 ) {
                if ( y != 0 ) {
                    append( "," )
                }
                append( "${ugo[y]}=" )
                for ( x in 0 until 3 ) {
                    if ( form.allProps[y][x].value ) {
                        append( rwx[x] )
                    }
                }
            }
        }.toString()

        val command = $( chmod --changes ${recurseFlag} ${permissionString} '${form.fileOrFolder.value}' )
        append( "$command\n" )
        command.runToTextBehaviour( this, "chmod", this:>onFinished )
    }

    meth onFinished( success : bool ) {
        if ( success ) {
            append( "\nSuccess\n" )
        }
    }

    override meth promptForm() = form

}


class ChangePermissionsForm( initialFileOrFolder : File ) : PromptForm( "Change Permissions" ) {

    val fileOrFolder = if (initialFileOrFolder.isFolder() ) {
        folderProperty( "Folder", initialFileOrFolder )
    } else {
        fileProperty( "File", initialFileOrFolder )
    }.apply {
        readOnly = true
    }


    val permissionsHeader = HorizontalGroup( "Permissions", 24,  TextFeature("R"), TextFeature("W"), TextFeature("X") )

    val ownerRead = boolProperty( "Owner Read", true )
    val ownerWrite = boolProperty( "Owner Write", true )
    val ownerExecute = boolProperty( "Owner Execute", false )
    val ownerPerm = HorizontalGroup( "Owner", 10, ownerRead, ownerWrite, ownerExecute )

    val groupRead = boolProperty( "Group Read", true )
    val groupWrite = boolProperty( "Group Write", true )
    val groupExecute = boolProperty( "Group Execute", false )
    val groupPerm = HorizontalGroup( "Group", 10, groupRead, groupWrite, groupExecute )

    val otherRead = boolProperty( "Other Read", true )
    val otherWrite = boolProperty( "Other Write", true )
    val otherExecute = boolProperty( "Other Execute", false )
    val otherPerm = HorizontalGroup( "Other", 10, otherRead, otherWrite, otherExecute )

    val recurse = boolProperty( "Apply changes Recursively", false )

    val ownerProps = listOf<BoolProperty>( ownerRead, ownerWrite, ownerExecute )
    val groupProps = listOf<BoolProperty>( groupRead, groupWrite, groupExecute )
    val otherProps = listOf<BoolProperty>( otherRead, otherWrite, otherExecute )
    val allProps = listOf<List<BoolProperty>>( ownerProps, groupProps, otherProps )

    init {

        val ls = $( ls -ld '$initialFileOrFolder' ).eval()
        val matcher = FileProperties.lsPattern.matcher( ls )
        if (matcher.find()) {
            val perms = matcher.group(1)
            // Convert rwxrwxrwx to boolean values of ownerRead etc.
            // NOTE, the first character is NOT parsed yet.
            for ( x in 0 until 3 ) {
                for ( y in 0 until 3 ) {
                    allProps[ y ][x].value = perms[1 + x + y * 3] != '-'
                }
            }
        }
    }

    override meth elements() = if ( fileOrFolder.value.isFolder() ) {
        listOf<FormElement>( fileOrFolder, permissionsHeader, ownerPerm, groupPerm, otherPerm, recurse )
    } else {
        listOf<FormElement>( fileOrFolder, permissionsHeader, ownerPerm, groupPerm, otherPerm )
    }

    override meth runner() = ChangePermissionsBehaviour( this )    

    override meth copy() : ChangePermissionsForm = ChangePermissionsForm( fileOrFolder.value ).apply {
        copyPropertiesFrom(this)
    }
}